Het gebruik van de Ollama Web Search API in Python

Maak AI-zoekagents aan met Python en Ollama

Inhoud

De Ollama Python-bibliotheek bevat nu native OLlama web zoekfunctie mogelijkheden. Met slechts een paar regels code kunt u uw lokale LLMs verrijken met real-time informatie van het web, waardoor hallucinaties worden verminderd en de nauwkeurigheid wordt verbeterd.

digitale ruimte

Aan de slag

Hoe installeer ik de Ollama Python-bibliotheek voor webzoekfuncties? Installeer versie 0.6.0 of hoger met pip install 'ollama>=0.6.0'. Deze versie bevat de functies web_search en web_fetch.

pip install 'ollama>=0.6.0'

Voor het beheren van Python-omgevingen en -pakketten, overweeg het gebruik van uv, een snelle Python-pakketbeheerder, of stel een virtuele omgeving in met venv om uw afhankelijkheden te isoleren.

Maak een API-sleutel aan vanuit uw Ollama account en stel deze in als omgevingsvariabele:

export OLLAMA_API_KEY="your_api_key"

Op Windows PowerShell:

$env:OLLAMA_API_KEY = "your_api_key"

Basiswebzoekfunctie

De eenvoudigste manier om met Ollama te zoeken op het web:

import ollama

# Eenvoudige webzoekfunctie
response = ollama.web_search("Wat is Ollama?")
print(response)

Uitvoer:

results = [
    {
        "title": "Ollama",
        "url": "https://ollama.com/",
        "content": "Cloudmodellen zijn nu beschikbaar in Ollama. .."
    },
    {
        "title": "Wat is Ollama? Kenmerken, Prijs en Toepassingen",
        "url": "https://www.walturn.com/insights/what-is-ollama",
        "content": "Onze diensten. .."
    },
    {
        "title": "Volledige Ollama Gids: Installatie, Gebruik & Codevoorbeelden",
        "url": "https://collabnix.com/complete-ollama-guide",
        "content": "Wordt lid van onze Discord-server. .."
    }
]

Aantal resultaten bepalen

import ollama

# Meer resultaten ophalen
response = ollama.web_search("nieuwste AI-nieuws", max_results=10)

for result in response.results:
    print(f"📌 {result.title}")
    print(f"   {result.url}")
    print(f"   {result.content[:100]}. ..")
    print()

Volledige Pagina Inhoud Ophalen

Wat is het verschil tussen web_search en web_fetch in de Ollama Python-bibliotheek? web_search voert een internetquery uit en retourneert meerdere zoekresultaten met titels, URL’s en samenvattingen. web_fetch haalt de volledige inhoud van een specifieke URL op, en retourneert de paginatitel, markdown-inhoud en links. De markdown-inhoud die wordt geretourneerd door web_fetch is ideaal voor verdere verwerking - als u HTML naar markdown wilt converteren in andere contexten, zie dan onze gids over HTML naar Markdown converteren met Python.

from ollama import web_fetch

result = web_fetch('https://ollama.com')
print(result)

Uitvoer:

WebFetchResponse(
    title='Ollama',
    content='[Cloudmodellen](https://ollama.com/blog/cloud-models) zijn nu beschikbaar in Ollama\n\n**Chat & bouw met open modellen**\n\n[Download](https://ollama.com/download) [Bekijk modellen](https://ollama.com/models)\n\nBeschikbaar voor macOS, Windows en Linux',
    links=['https://ollama.com/', 'https://ollama.com/models', 'https://github.com/ollama/ollama']
)

Zoeken en Ophalen Combineren

Een veelvoorkomend patroon is eerst te zoeken en vervolgens de volledige inhoud op te halen van relevante resultaten:

from ollama import web_search, web_fetch

# Zoek naar informatie
search_results = web_search("Ollama nieuwe functies 2025")

# Haal de volledige inhoud op van het eerste resultaat
if search_results.results:
    first_url = search_results.results[0].url
    full_content = web_fetch(first_url)
    
    print(f"Titel: {full_content.title}")
    print(f"Inhoud: {full_content.content[:500]}. ..")
    print(f"Links gevonden: {len(full_content.links)}")

Een Zoekagent Bouwen

Welke Python-modellen werken het beste voor Ollama zoekagenten? Modellen met sterke toolgebruiksmogelijkheden werken het beste, waaronder qwen3, gpt-oss en cloudmodellen zoals qwen3:480b-cloud en deepseek-v3.1-cloud. Voor geavanceerde toepassingen die gestructureerde uitvoer van deze modellen vereisen, zie dan onze gids over LLMs met Gestructureerde Uitvoer met Ollama en Qwen3.

Eerst, trek een geschikt model:

ollama pull qwen3:4b

Eenvoudige Zoekagent

Hieronder staat een basiszoekagent die autonom kan beslissen wanneer te zoeken:

from ollama import chat, web_fetch, web_search

available_tools = {'web_search': web_search, 'web_fetch': web_fetch}

messages = [{'role': 'user', 'content': "wat is ollama's nieuwe motor"}]

while True:
    response = chat(
        model='qwen3:4b',
        messages=messages,
        tools=[web_search, web_fetch],
        think=True
    )
    
    if response.message.thinking:
        print('🧠 Denken:', response.message.thinking[:200], '. ..')
    
    if response.message.content:
        print('💬 Antwoord:', response.message.content)
    
    messages.append(response.message)
    
    if response.message.tool_calls:
        print('🔧 Tool oproepen:', response.message.tool_calls)
        for tool_call in response.message.tool_calls:
            function_to_call = available_tools.get(tool_call.function.name)
            if function_to_call:
                args = tool_call.function.arguments
                result = function_to_call(**args)
                print('📥 Resultaat:', str(result)[:200], '. ..')
                # Kort het resultaat af voor beperkte contextlengtes
                messages.append({
                    'role': 'tool', 
                    'content': str(result)[:2000 * 4], 
                    'tool_name': tool_call.function.name
                })
            else:
                messages.append({
                    'role': 'tool', 
                    'content': f'Tool {tool_call.function.name} niet gevonden', 
                    'tool_name': tool_call.function.name
                })
    else:
        break

Hoe ga ik om met grote webzoekresultaten in Python? Kort resultaten af om binnen contextlimieten te blijven. De aanbevolen aanpak is om de resultaatstring af te knippen tot ongeveer 8000 tekens (2000 tokens × 4 tekens) voordat deze aan het model wordt doorgegeven.

Geavanceerde Zoekagent met Foutafhandeling

Hieronder staat een verbeterde versie met betere foutafhandeling:

from ollama import chat, web_fetch, web_search
import json

class ZoekAgent:
    def __init__(self, model: str = 'qwen3:4b'):
        self.model = model
        self.tools = {'web_search': web_search, 'web_fetch': web_fetch}
        self.messages = []
        self.max_iterations = 10
        
    def query(self, vraag: str) -> str:
        self.messages = [{'role': 'user', 'content': vraag}]
        
        for iteratie in range(self.max_iterations):
            try:
                response = chat(
                    model=self.model,
                    messages=self.messages,
                    tools=[web_search, web_fetch],
                    think=True
                )
            except Exception as e:
                return f"Fout tijdens chat: {e}"
            
            self.messages.append(response.message)
            
            # Als er geen tool oproepen zijn, hebben we een eindantwoord
            if not response.message.tool_calls:
                return response.message.content or "Geen antwoord gegenereerd"
            
            # Voer tool oproepen uit
            for tool_call in response.message.tool_calls:
                result = self._tool_execute(tool_call)
                self.messages.append({
                    'role': 'tool',
                    'content': result,
                    'tool_name': tool_call.function.name
                })
        
        return "Maximale iteraties bereikt zonder eindantwoord"
    
    def _tool_execute(self, tool_call) -> str:
        func_name = tool_call.function.name
        args = tool_call.function.arguments
        
        if func_name not in self.tools:
            return f"Onbekende tool: {func_name}"
        
        try:
            result = self.tools[func_name](**args)
            # Kort voor contextlimieten
            result_str = str(result)
            if len(result_str) > 8000:
                result_str = result_str[:8000] + "... [afgekort]"
            return result_str
        except Exception as e:
            return f"Toolfout: {e}"

# Gebruik
agent = ZoekAgent(model='qwen3:4b')
antwoord = agent.query("Wat zijn de nieuwste functies in Ollama?")
print(antwoord)

Asynchrone Webzoekfunctie

Kan ik Ollama Python-webzoekfuncties gebruiken met asynchrone code? Ja, de Ollama Python-bibliotheek ondersteunt asynchrone bewerkingen. Gebruik AsyncClient voor niet-blokkerende webzoek- en ophaalbewerkingen in asynchrone toepassingen. Voor prestatiecomparaties tussen Python en andere talen in serverloze contexten, zie dan onze analyse van AWS Lambda prestaties over JavaScript, Python en Golang.

import asyncio
from ollama import AsyncClient

async def async_search():
    client = AsyncClient()
    
    # Voer meerdere zoekacties tegelijk uit
    taken = [
        client.web_search("Ollama kenmerken"),
        client.web_search("lokale LLM-hulpmiddelen"),
        client.web_search("AI zoekagenten"),
    ]
    
    resultaten = await asyncio.gather(*taken)
    
    for i, resultaat in enumerate(resultaten):
        print(f"Zoekactie {i + 1}:")
        for r in resultaat.results[:2]:
            print(f"  - {r.title}")
        print()

# Voer asynchrone zoekactie uit
asyncio.run(async_search())

Asynchrone Zoekagent

import asyncio
from ollama import AsyncClient

async def async_research_agent(vraag: str):
    client = AsyncClient()
    messages = [{'role': 'user', 'content': vraag}]
    
    while True:
        response = await client.chat(
            model='qwen3:4b',
            messages=messages,
            tools=[client.web_search, client.web_fetch],
        )
        
        messages.append(response.message)
        
        if not response.message.tool_calls:
            return response.message.content
        
        # Voer tool oproepen tegelijk uit
        tool_taken = []
        for tool_call in response.message.tool_calls:
            if tool_call.function.name == 'web_search':
                taak = client.web_search(**tool_call.function.arguments)
            elif tool_call.function.name == 'web_fetch':
                taak = client.web_fetch(**tool_call.function.arguments)
            else:
                continue
            tool_taken.append((tool_call.function.name, taak))
        
        # Resultaten verzamelen
        for tool_naam, taak in tool_taken:
            resultaat = await taak
            messages.append({
                'role': 'tool',
                'content': str(resultaat)[:8000],
                'tool_name': tool_naam
            })

# Uitvoeren
antwoord = asyncio.run(async_research_agent("Wat is nieuw in Python 3.13?"))
print(antwoord)

Contextlengte en Prestaties

Welke contextlengte moet ik instellen voor Python-zoekagenten? Stel de contextlengte in op ongeveer 32000 tokens voor redelijke prestaties. Zoekagenten werken het beste met volledige contextlengte, omdat web_search en web_fetch duizenden tokens kunnen retourneren.

from ollama import chat, web_search

# Stel hogere context in voor zoekintensieve taken
response = chat(
    model='qwen3:4b',
    messages=[{'role': 'user', 'content': 'Onderzoek de nieuwste AI-ontwikkelingen'}],
    tools=[web_search],
    options={
        'num_ctx': 32768,  # 32K context
    }
)

MCP-serverintegratie

Ollama biedt een Python-MCP-server die webzoekfuncties mogelijk maakt in elke MCP-client. Voor een uitgebreide gids over het bouwen van MCP-servers in Python met webzoek- en scrapingsfunctionaliteiten, zie dan onze gedetailleerde tutorial over MCP-servers bouwen in Python.

Cline-integratie

Stel MCP-servers in in Cline-instellingen:

MCP-servers beheren → MCP-servers instellen → Toevoegen:

{
  "mcpServers": {
    "web_search_and_fetch": {
      "type": "stdio",
      "command": "uv",
      "args": ["run", "pad/naar/web-search-mcp.py"],
      "env": { "OLLAMA_API_KEY": "your_api_key_here" }
    }
  }
}

Codex-integratie

Voeg toe aan ~/.codex/config.toml:

[mcp_servers.web_search]
command = "uv"
args = ["run", "pad/naar/web-search-mcp.py"]
env = { "OLLAMA_API_KEY" = "your_api_key_here" }

Eigen MCP-server maken

#!/usr/bin/env python3
"""Eenvoudige MCP-server voor Ollama webzoekfunctie."""

import os
from mcp.server import Server
from mcp.types import Tool, TextContent
from ollama import web_search, web_fetch

app = Server("ollama-web-search")

@app.tool()
async def search_web(query: str, max_results: int = 5) -> str:
    """Zoek op het web naar informatie."""
    resultaten = web_search(query, max_results=max_results)
    
    output = []
    for r in resultaten.results:
        output.append(f"**{r.title}**\n{r.url}\n{r.content}\n")
    
    return "\n---\n".join(output)

@app.tool()
async def fetch_page(url: str) -> str:
    """Haal de volledige inhoud van een webpagina op."""
    resultaat = web_fetch(url)
    return f"# {resultaat.title}\n\n{resultaat.content}"

if __name__ == "__main__":
    app.run()

Praktijkvoorbeelden

Deze voorbeelden tonen realistische toepassingen van Ollama’s webzoek-API. U kunt deze patronen uitbreiden om complexere systemen te bouwen - bijvoorbeeld, zoekresultaten combineren met PDF genereren in Python om onderzoeksrapporten te maken.

Nieuwsverkorter

from ollama import chat, web_search

def summarize_news(topic: str) -> str:
    # Zoek naar recente nieuws
    resultaten = web_search(f"{topic} nieuwste nieuws", max_results=5)
    
    # Formateer zoekresultaten voor het model
    news_content = "\n\n".join([
        f"**{r.title}**\n{r.content}"
        for r in resultaten.results
    ])
    
    # Vraag het model om een samenvatting
    response = chat(
        model='qwen3:4b',
        messages=[{
            'role': 'user',
            'content': f"Samenvat deze nieuwsitems over {topic}:\n\n{news_content}"
        }]
    )
    
    return response.message.content

samenvatting = summarize_news("kunstmatige intelligentie")
print(samenvatting)

Onderzoeksassistent

from ollama import chat, web_search, web_fetch
from dataclasses import dataclass

@dataclass
class OnderzoeksResultaat:
    vraag: str
    bronnen: list
    antwoord: str

def onderzoek(vraag: str) -> OnderzoeksResultaat:
    # Zoek naar relevante informatie
    zoek_resultaten = web_search(vraag, max_results=3)
    
    # Haal volledige inhoud op van topbronnen
    bronnen = []
    volledige_inhoud = []
    
    for resultaat in zoek_resultaten.results[:3]:
        try:
            pagina = web_fetch(resultaat.url)
            bronnen.append(resultaat.url)
            volledige_inhoud.append(f"Bron: {resultaat.url}\n{pagina.content[:2000]}")
        except:
            continue
    
    # Genereer een uitgebreid antwoord
    context = "\n\n---\n\n".join(volledige_inhoud)
    
    response = chat(
        model='qwen3:4b',
        messages=[{
            'role': 'user',
            'content': f"""Op basis van de volgende bronnen, beantwoord deze vraag: {vraag}

Bronnen:
{context}

Geef een uitgebreid antwoord met citaten van de bronnen."""
        }]
    )
    
    return OnderzoeksResultaat(
        vraag=vraag,
        bronnen=bronnen,
        antwoord=response.message.content
    )

# Gebruik
resultaat = onderzoek("Hoe werkt Ollama's nieuwe modellenplanning?")
print(f"Vraag: {resultaat.vraag}")
print(f"Bronnen: {resultaat.bronnen}")
print(f"Antwoord: {resultaat.antwoord}")

Aanbevolen Modellen

Model Parameters Bestemd voor
qwen3:4b 4B Snel lokale zoekacties
qwen3 8B Algemene doeleinden
gpt-oss Verschillend Onderzoeksopdrachten
qwen3:480b-cloud 480B Complexe redenering (cloud)
gpt-oss:120b-cloud 120B Langere onderzoeksrapporten (cloud)
deepseek-v3.1-cloud - Geavanceerde analyse (cloud)

Best Practices

  1. Resultaten afkorten: Kort altijd webresultaten af om binnen contextlimieten te blijven (~8000 tekens)
  2. Foutafhandeling: Omsluit tooloproepen in try/except voor netwerkuitval
  3. Rate limiting: Respecteer Ollama’s API-rate limieten voor webzoekacties
  4. Contextlengte: Gebruik ~32000 tokens voor zoekagenten
  5. Asynchrone voor schaalbaarheid: Gebruik AsyncClient voor concurrente bewerkingen
  6. Testen: Schrijf eenheidstests voor uw zoekagenten om betrouwbaarheid te waarborgen
  7. Python basis: Houd een Python handleiding bij voor snel overzicht van syntaxis en veelvoorkomende patronen