# 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( en streaming guide.
---
## Building Blocks Die Je 80% van de Tijd Gebruikt
### 1) Prompts en Output Parsing
- Gebruik `ChatPromptTemplate` voor gestructureerde prompts.
- Parse outputs met `StrOutputParser` of JSON parsers voor getypte responses.
```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(
"""
Vat de volgende tekst samen in 3 opsommingstekens:
---
{text}
"""
)
parser = StrOutputParser
chain = prompt | llm | parser
summary = chain.invoke({"text": "LangChain helpt bij het bouwen van LLM-apps met RAG en 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 = .
---
## Van Prototype Naar Productie: Een Stapsgewijze Blauwdruk
### Stap 1: Definieer het Gebruikersverhaal
- Wie is de gebruiker? Welke taak proberen ze te voltooien?
- Voorbeeld: “Een supportmedewerker die productvragen beantwoordt uit interne documenten en recente tickets.”
### Stap 2: Kies de Minimaal Haalbare Stack
- Model: Kies een redelijk geprijsd, betrouwbaar model (bijv. GPT-4o-mini of een frontier open model).
- Data: Bepaal of je nu RAG nodig hebt. Zo ja, begin dan lokaal met FAISS.
- I/O: Gebruik LCEL voor snelle iteratie; vermijd aangepaste glue code.
### Stap 3: Implementeer een Schone RAG Loop
- Splits documenten correct.
- Indexeer embeddings.
- Prompt met context en citaten.
- Voeg een vangrail toe om hallucinaties te voorkomen wanneer er geen relevante context wordt gevonden.
```python
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
qa_prompt = ChatPromptTemplate.from_template(
"""
Beantwoord de vraag ALLEEN met behulp van de onderstaande CONTEXT. Als het antwoord niet
in de context staat, zeg dan "Ik weet het niet." Voeg geciteerde document-ID's toe.
CONTEXT:
{context}
VRAAG: {question}
"""
)
parser = StrOutputParser
rag_chain = (RunnableParallel(context=retriever, question=RunnableLambda(lambda x: x.
### Stap 5: Getypte Outputs en Validatie
- Gebruik `PydanticOutputParser` of JSON schema om structuur af te dwingen voor API-responses.
- Valideer velden om modeldrift op te vangen.
### Stap 6: Tooling en Functieaanroepen voor Echte Taken
- Introduceer tools spaarzaam.
- Gemeenschappelijke tools: rekenmachine, web zoeken, SQL query executor, code runner.
- Beschrijf toolmogelijkheden duidelijk in docstrings.
### Stap 7: Hardening
- Rate limit en retry strategieën.
- Timeouts en circuit breakers.
- Veiligheidsfilters en content checks.
### Stap 8: Evaluatie & Continue Verbetering
- Test met golden datasets (input → verwachte output).
- Evalueer getrouwheid, volledigheid van antwoorden en nauwkeurigheid van citaten.
- Meet retrieval hit rate en latency.
---
## Gemeenschappelijke Patronen en Valkuilen
- Begin simpel: Ketens vóór agents. Je krijgt voorspelbaarheid en lagere kosten.
- Chunking doet ertoe: Het afstemmen van de chunkgrootte/overlap kan de retrieval kwaliteit meer veranderen dan het verwisselen van het model.
- Prompt leakage: Stop niet de hele keuken in systeem prompts; houd ze gefocust.
- Determinisme: Stel `temperature=0` in voor evaluatie en kritieke workflows.
- Streaming UX: Stream tokens naar de UI terwijl de rest van het systeem assets ophaalt of context preloadt.
- Gestructureerde outputs: Gebruik parsers om downstream integratie pijnloos te maken.
---
## Een Volledig Mini Project: Docs Q&A Met Citaten
Dit voorbeeld verbindt alles: ingestie, RAG, antwoord generatie en 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": "Ons Pro-abonnement ondersteunt 1M context tokens en omvat prioritaire ondersteuning.",
"limits": "De API rate limit is 60 verzoeken per minuut voor Pro-gebruikers.",
"security": "We slaan logs 30 dagen op, tenzij logging is uitgeschakeld door de beheerder.",
}
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(
"""
Je bent een supportassistent. Gebruik de CONTEXT om te antwoorden.
Als je het niet zeker weet, zeg dan "Ik weet het niet". Vermeld citaten van bron-ID's.
CONTEXT:
{context}
VRAAG: {question}
"""
)
# 4) Model en 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)