# pip install langchain langchain-openai
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
# 1) Model
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
# 2) Prompt
prompt = ChatPromptTemplate.from_messages( and streaming guide.
---
## Byggstenar du kommer att använda 80 % av tiden
### 1) Prompts och utdataparsning
- Använd `ChatPromptTemplate` för strukturerade prompts.
- Parsa utdata med `StrOutputParser` eller JSON-parsers för typade svar.
```python
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_template(
"""
Summera följande text i 3 punkter:
---
{text}
"""
)
parser = StrOutputParser
chain = prompt | llm | parser
summary = chain.invoke({"text": "LangChain helps build LLM apps with RAG and tools."})
print(summary)

# pip install faiss-cpu tiktoken
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
# Prepare documents
texts = .
---
## Från prototyp till produktion: En steg-för-steg-ritning
### Steg 1: Definiera användarberättelsen
- Vem är användaren? Vilket jobb försöker de få gjort?
- Exempel: "En supportagent som svarar på produktfrågor från interna dokument och senaste ärenden."
### Steg 2: Välj den minsta möjliga stacken
- Modell: Välj en prisvärd, pålitlig modell (t.ex. GPT-4o-mini eller en ledande öppen modell).
- Data: Bestäm om du behöver RAG nu. Om ja, börja med FAISS lokalt.
- I/O: Använd LCEL för snabb iteration; undvik anpassad limkod.
### Steg 3: Implementera en ren RAG-loop
- Dela dokument korrekt.
- Indexera inbäddningar.
- Prompt med kontext och citeringar.
- Lägg till en skyddsräls för att undvika hallucinationer när ingen relevant kontext hittas.
```python
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
qa_prompt = ChatPromptTemplate.from_template(
"""
Svara på frågan med ENDAST KONTEXTEN nedan. Om svaret inte finns
i kontexten, säg "Jag vet inte." Inkludera citerade dokument-ID:n.
KONTEXT:
{context}
FRÅGA: {question}
"""
)
parser = StrOutputParser
rag_chain = (RunnableParallel(context=retriever, question=RunnableLambda(lambda x: x.
### Steg 5: Typade utdata och validering
- Använd `PydanticOutputParser` eller JSON-schema för att tvinga fram struktur för API-svar.
- Validera fält för att fånga upp modellförändringar.
### Steg 6: Verktyg och funktionsanrop för verkliga uppgifter
- Introducera verktyg sparsamt.
- Vanliga verktyg: kalkylator, webbsökning, SQL-frågeexekverare, kodkörning.
- Beskriv tydligt verktygets funktioner i docstrings.
### Steg 7: Härdning
- Hastighetsbegränsning och strategier för omförsök.
- Timeouts och strömbrytare.
- Säkerhetsfilter och innehållskontroller.
### Steg 8: Utvärdering och kontinuerlig förbättring
- Testa med gyllene dataset (indata → förväntad utdata).
- Utvärdera trohet, svarsfullständighet och citeringsnoggrannhet.
- Mät hämtningsfrekvens och latens.
---
## Vanliga mönster och fallgropar
- Börja enkelt: Kedjor före agenter. Du får förutsägbarhet och lägre kostnad.
- Chunking spelar roll: Justering av chunk-storlek/överlappning kan ändra hämtningskvaliteten mer än modellbytet.
- Promptläckage: Stoppa inte ner hela köket i systemprompts; håll dem fokuserade.
- Determinism: Sätt `temperature=0` för utvärdering och kritiska arbetsflöden.
- Streaming UX: Strömma tokens till användargränssnittet medan resten av systemet hämtar tillgångar eller förladdar kontext.
- Strukturerade utdata: Använd parsers för att göra nedströmsintegration smärtfri.
---
## Ett komplett miniprojekt: Dokumentfrågor och svar med citeringar
Det här exemplet knyter ihop allt: inmatning, RAG, svarsgenerering och streaming.
```python
# pip install langchain langchain-openai faiss-cpu tiktoken
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableParallel, RunnableLambda
# 1) Ingest
corpus = {
"pricing": "Our Pro plan supports 1M context tokens and includes priority support.",
"limits": "The API rate limit is 60 requests per minute for Pro users.",
"security": "We store logs for 30 days unless logging is disabled by the admin.",
}
splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)
all_chunks, ids = [], []
for doc_id, text in corpus.items:
for i, chunk in enumerate(splitter.split_text(text)):
all_chunks.append(chunk)
ids.append(f"{doc_id}-{i}")
# 2) Index
db = FAISS.from_texts(all_chunks, OpenAIEmbeddings)
retriever = db.as_retriever(k=4)
# 3) Prompt
prompt = ChatPromptTemplate.from_template(
"""
Du är en supportassistent. Använd KONTEXTEN för att svara.
Om du är osäker, säg "Jag vet inte." Inkludera citeringar av käll-ID:n.
KONTEXT:
{context}
FRÅGA: {question}
"""
)
# 4) Model and parser
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
parser = StrOutputParser
# 5) Compose chain
rag = (
RunnableParallel(
context=retriever,
question=RunnableLambda(lambda x: x["question"]) # pass-through
)
| prompt
| llm
| parser
)
# 6) Ask a question
for chunk in rag.stream({"question": "What are Pro rate limits and log retention?"}):
print(chunk, end="", flush=True)