AI Agents bouwen met LangChain en Python
Stap-voor-stap tutorial voor het bouwen van autonome AI agents met LangChain. Van basis tool-use tot multi-agent systemen met memory management.
JJan de Maker
7 dagen geledenAI AgentsLangChainPythonTutorialReAct
# AI Agents bouwen met LangChain en Python
## Wat zijn AI Agents?
AI Agents zijn systemen die autonoom taken uitvoeren door tools te gebruiken en beslissingen te nemen. Anders dan een chatbot die alleen tekst genereert, kan een agent acties ondernemen: databases doorzoeken, API's aanroepen, berekeningen maken en bestanden verwerken.
De kern van een agent is een loop:
1. Ontvang een taak
2. Bedenk welke tool je nodig hebt (reasoning)
3. Gebruik de tool (acting)
4. Observeer het resultaat
5. Herhaal tot de taak voltooid is
Dit staat bekend als het **ReAct** (Reasoning + Acting) patroon.
## Setup
```bash
pip install langchain langchain-openai langchain-community
```
Zorg dat je een OpenAI API key hebt:
```bash
export OPENAI_API_KEY="sk-..."
```
## Je eerste agent: een research assistent
Laten we een agent bouwen die vragen kan beantwoorden door het web te doorzoeken en berekeningen te maken.
### Stap 1: Definieer tools
```python
from langchain_openai import ChatOpenAI
from langchain.agents import tool
from langchain_community.tools import DuckDuckGoSearchRun
# Web search tool
search = DuckDuckGoSearchRun()
@tool
def calculate(expression: str) -> str:
"""Bereken een wiskundige expressie. Input: een Python expressie als string."""
try:
result = eval(expression)
return str(result)
except Exception as e:
return f"Fout bij berekenen: {e}"
@tool
def get_current_date() -> str:
"""Geeft de huidige datum en tijd."""
from datetime import datetime
return datetime.now().strftime("%Y-%m-%d %H:%M")
tools = [search, calculate, get_current_date]
```
### Stap 2: Maak de agent
```python
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub
# Haal een bewezen ReAct prompt op
prompt = hub.pull("hwchase17/react")
# Initialiseer het LLM
llm = ChatOpenAI(model="gpt-4o", temperature=0)
# Maak de agent
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
verbose=True,
max_iterations=10,
handle_parsing_errors=True
)
```
### Stap 3: Gebruik de agent
```python
result = agent_executor.invoke({
"input": "Wat is de huidige Bitcoin prijs in euro's? Bereken hoeveel 0.5 BTC waard is."
})
print(result["output"])
```
De agent zal:
1. Het web doorzoeken voor de huidige Bitcoin prijs
2. De calculator gebruiken om 0.5 * prijs te berekenen
3. Een samenvatting geven
## Memory toevoegen
Agents zonder geheugen vergeten alles na elke interactie. Voeg memory toe voor conversational agents:
```python
from langchain.memory import ConversationBufferWindowMemory
memory = ConversationBufferWindowMemory(
memory_key="chat_history",
k=10, # onthoud de laatste 10 berichten
return_messages=True
)
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
memory=memory,
verbose=True
)
# Eerste vraag
agent_executor.invoke({"input": "Zoek informatie over n8n automation tool"})
# Follow-up (de agent onthoudt de context)
agent_executor.invoke({"input": "Hoe verhoudt het zich tot Make.com qua prijs?"})
```
## Custom tools bouwen
De kracht van agents zit in custom tools. Hier een voorbeeld van een tool die je CRM doorzoekt:
```python
import requests
@tool
def search_crm(query: str) -> str:
"""Doorzoek het CRM op klantinformatie. Input: zoekterm (naam, email of bedrijf)."""
response = requests.get(
"https://api.hubspot.com/crm/v3/objects/contacts/search",
headers={"Authorization": f"Bearer {HUBSPOT_API_KEY}"},
json={
"filterGroups": [{
"filters": [{
"propertyName": "email",
"operator": "CONTAINS_TOKEN",
"value": query
}]
}]
}
)
results = response.json().get("results", [])
if not results:
return "Geen resultaten gevonden."
contact = results[0]["properties"]
return f"Naam: {contact.get('firstname')} {contact.get('lastname')}, Bedrijf: {contact.get('company')}, Email: {contact.get('email')}"
```
## Best practices
1. **Beperk het aantal tools** — Meer dan 7 tools maakt de agent verward. Groepeer gerelateerde functies.
2. **Schrijf goede tool descriptions** — De agent beslist welke tool te gebruiken op basis van de description. Wees specifiek.
3. **Stel max_iterations in** — Voorkom infinite loops met een maximum van 10-15 iteraties.
4. **Handle parsing errors** — LLMs produceren soms onverwachte output. Gebruik `handle_parsing_errors=True`.
5. **Log alles** — Gebruik LangFuse of LangSmith om agent decisions te loggen en analyseren.
6. **Temperature = 0** — Voor agents wil je deterministische output. Gebruik temperature=0.
7. **Human-in-the-loop** — Voor kritieke acties (e-mail versturen, data wijzigen) vraag bevestiging.
## Van agent naar productie
Een agent in een Jupyter notebook is leuk. Een agent in productie vereist meer:
- **Fallback mechanism**: als de agent faalt, geef een graceful error response
- **Rate limiting**: beperk het aantal API calls per gebruiker
- **Caching**: cache veelvoorkomende tool-resultaten
- **Monitoring**: track kosten, latency en success rate per agent run
- **Testing**: schrijf tests voor je tools en agent scenarios
## Conclusie
AI Agents zijn een krachtig patroon voor het automatiseren van complexe taken. Begin simpel met 2-3 tools, bouw uit naar meer complexiteit, en investeer in monitoring en testing voordat je naar productie gaat.