LangChain met de Gemini API

LangChain en Gemini

LangChain is een framework voor het bouwen van applicaties met taalmodellen. Het biedt abstracties voor chains (sequentiele prompting), memory (gespreksgeschiedenis), agents (autonome tools) en RAG (retrieval-augmented generation). Gemini werkt als LLM-backend via de officiele integratie in het pakket langchain-google-genai.

Sinds langchain-google-genai 4.0 draait die integratie op de geconsolideerde google-genai SDK en kan dezelfde klasse ChatGoogleGenerativeAI zowel de Gemini Developer API (met een API-sleutel) als Vertex AI (met een Google Cloud-project) aanspreken.

Installatie

pip install langchain langchain-google-genai

Voor Vertex AI gebruik je het aparte pakket:

pip install langchain langchain-google-vertexai

Basisgebruik

from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_core.messages import HumanMessage, SystemMessage
import os

llm = ChatGoogleGenerativeAI(
    model="gemini-2.5-flash",
    google_api_key=os.environ["GEMINI_API_KEY"],
    temperature=0.7,
    max_output_tokens=1024,
)

messages = [
    SystemMessage(content="Je bent een expert in Python-programmeren."),
    HumanMessage(content="Leg list comprehensions uit met drie voorbeelden."),
]

response = llm.invoke(messages)
print(response.content)

Prompt templates

from langchain_core.prompts import ChatPromptTemplate

template = ChatPromptTemplate.from_messages([
    ("system", "Je bent een {rol} specialist. Beantwoord vragen in het {taal}."),
    ("human", "{vraag}"),
])

chain = template | llm

response = chain.invoke({
    "rol": "cybersecurity",
    "taal": "Nederlands",
    "vraag": "Wat zijn de meest voorkomende SQL injection aanvallen?",
})
print(response.content)

Chains koppelen met LCEL

Met LangChain Expression Language (LCEL) koppel je losse stappen tot een pipeline via de |-operator. Hieronder vat de eerste chain een tekst samen, waarna de tweede chain die samenvatting naar het Engels vertaalt.

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

samenvatting_chain = (
    ChatPromptTemplate.from_template("Vat de volgende tekst samen in 3 punten:
{tekst}")
    | llm
    | StrOutputParser()
)

vertaling_chain = (
    ChatPromptTemplate.from_template("Vertaal naar het Engels:
{tekst}")
    | llm
    | StrOutputParser()
)

pipeline = samenvatting_chain | (lambda s: {"tekst": s}) | vertaling_chain

result = pipeline.invoke({"tekst": lange_nederlandstalige_tekst})
print(result)

RAG-systeem met LangChain en Gemini

Een RAG-pipeline laadt documenten, splitst ze in stukken, zet die om naar embeddings en haalt bij elke vraag de relevante stukken op als context voor het model.

from langchain_google_genai import GoogleGenerativeAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
import os

loader = TextLoader("kennisbank.txt")
docs = loader.load()

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
chunks = text_splitter.split_documents(docs)

embeddings = GoogleGenerativeAIEmbeddings(
    model="models/gemini-embedding-001",
    google_api_key=os.environ["GEMINI_API_KEY"],
)

vectorstore = Chroma.from_documents(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True,
)

result = qa_chain.invoke({"query": "Wat is het retourbeleid?"})
print(result["result"])

print("Bronnen:")
for doc in result["source_documents"]:
    print(f"- {doc.metadata.get('source', 'onbekend')}")

Agents met tool-calling

Een agent laat Gemini zelf beslissen welke tools het aanroept om een vraag te beantwoorden. Hieronder krijgt een verkoopassistent een rekenmachine en een productzoeker.

from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain.tools import tool
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

@tool
def rekenmachine(berekening: str) -> str:
    """Voer een wiskundige berekening uit. Invoer: wiskundige expressie als string."""
    try:
        return str(eval(berekening))
    except Exception as e:
        return f"Fout: {e}"

@tool
def zoek_product(product_naam: str) -> str:
    """Zoek productinformatie op. Invoer: productnaam."""
    producten = {"laptop": "999 euro, 16GB RAM, 512GB SSD", "tablet": "499 euro, 64GB"}
    return producten.get(product_naam.lower(), "Product niet gevonden")

tools = [rekenmachine, zoek_product]

prompt = ChatPromptTemplate.from_messages([
    ("system", "Je bent een verkoopassistent. Gebruik de beschikbare tools."),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = agent_executor.invoke({
    "input": "Wat kost een laptop en een tablet samen?",
})
print(result["output"])