Ollama Web Search API in Python nutzen

KI-Suchagenten mit Python und Ollama erstellen

Inhaltsverzeichnis

Ollamas Python-Bibliothek umfasst nun native Ollama Websuche-Funktionen. Mit nur wenigen Zeilen Code können Sie Ihre lokalen LLMs mit Echtzeitinformationen aus dem Web ergänzen, was Halluzinationen reduziert und die Genauigkeit verbessert.

digitaler Raum

Erste Schritte

Wie installiere ich die Ollama Python-Bibliothek für die Websuche? Installieren Sie Version 0.6.0 oder höher mit pip install 'ollama>=0.6.0'. Diese Version enthält die Funktionen web_search und web_fetch.

pip install 'ollama>=0.6.0'

Um Python-Umgebungen und Pakete zu verwalten, sollten Sie die Verwendung von uv, einem schnellen Python-Paketmanager, in Betracht ziehen, oder eine virtuelle Umgebung mit venv einrichten, um Ihre Abhängigkeiten zu isolieren.

Erstellen Sie einen API-Schlüssel von Ihrem Ollama-Konto und setzen Sie ihn als Umgebungsvariable:

export OLLAMA_API_KEY="your_api_key"

In Windows PowerShell:

$env:OLLAMA_API_KEY = "your_api_key"

Grundlegende Websuche

Der einfachste Weg, mit Ollama im Web zu suchen:

import ollama

# Einfache Websuche
response = ollama.web_search("What is Ollama?")
print(response)

Ausgabe:

results = [
    {
        "title": "Ollama",
        "url": "https://ollama.com/",
        "content": "Cloud models are now available in Ollama..."
    },
    {
        "title": "What is Ollama? Features, Pricing, and Use Cases",
        "url": "https://www.walturn.com/insights/what-is-ollama",
        "content": "Our services..."
    },
    {
        "title": "Complete Ollama Guide: Installation, Usage & Code Examples",
        "url": "https://collabnix.com/complete-ollama-guide",
        "content": "Join our Discord Server..."
    }
]

Kontrolle der Ergebnisanzahl

import ollama

# Weitere Ergebnisse abrufen
response = ollama.web_search("latest AI news", max_results=10)

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

Abruf des vollständigen Seiteninhalts

Was ist der Unterschied zwischen web_search und web_fetch in Ollama Python? web_search fragt das Internet ab und liefert mehrere Suchergebnisse mit Titeln, URLs und Ausschnitten zurück. web_fetch ruft den vollständigen Inhalt einer bestimmten URL ab und gibt den Seitentitel, den Markdown-Inhalt und die Links zurück. Der von web_fetch zurückgegebene Markdown-Inhalt ist perfekt für eine weitere Verarbeitung – falls Sie HTML in anderen Kontexten in Markdown konvertieren müssen, finden Sie in unserem Leitfaden zu HTML in Markdown mit Python konvertieren weitere Informationen.

from ollama import web_fetch

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

Ausgabe:

WebFetchResponse(
    title='Ollama',
    content='[Cloud models](https://ollama.com/blog/cloud-models) are now available in Ollama\n\n**Chat & build with open models**\n\n[Download](https://ollama.com/download) [Explore models](https://ollama.com/models)\n\nAvailable for macOS, Windows, and Linux',
    links=['https://ollama.com/', 'https://ollama.com/models', 'https://github.com/ollama/ollama']
)

Kombination von Suche und Abruf

Ein häufiges Muster besteht darin, zunächst zu suchen und dann den vollständigen Inhalt aus relevanten Ergebnissen abzurufen:

from ollama import web_search, web_fetch

# Nach Informationen suchen
search_results = web_search("Ollama new features 2025")

# Vollständigen Inhalt vom ersten Ergebnis abrufen
if search_results.results:
    first_url = search_results.results[0].url
    full_content = web_fetch(first_url)
    
    print(f"Title: {full_content.title}")
    print(f"Content: {full_content.content[:500]}...")
    print(f"Links found: {len(full_content.links)}")

Aufbau eines Suchagents

Welche Python-Modelle eignen sich am besten für Ollama-Suchagenten? Modelle mit starken Fähigkeiten zur Tool-Nutzung eignen sich am besten, einschließlich qwen3, gpt-oss und Cloud-Modelle wie qwen3:480b-cloud und deepseek-v3.1-cloud. Für weiter fortgeschrittene Anwendungsfälle, die strukturierte Ausgaben von diesen Modellen erfordern, werfen Sie einen Blick auf unseren Leitfaden zu LLMs mit strukturiertem Output unter Verwendung von Ollama und Qwen3. Sobald Tools oder JSON-Modus Payloads zurückgeben, die Sie vertrauen, deckt Validierung von LLM-Strukturiertem Output in Python, der standhält das Parsing, Pydantic-Prüfungen, Wiederholungen und Tests auf der Anwendungsebene ab.

Ziehen Sie zuerst ein leistungsfähiges Modell:

ollama pull qwen3:4b

Einfacher Suchagent

Hier ist ein grundlegender Suchagent, der autonom entscheiden kann, wann gesucht werden soll:

from ollama import chat, web_fetch, web_search

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

messages = [{'role': 'user', 'content': "what is ollama's new engine"}]

while True:
    response = chat(
        model='qwen3:4b',
        messages=messages,
        tools=[web_search, web_fetch],
        think=True
    )
    
    if response.message.thinking:
        print('🧠 Thinking:', response.message.thinking[:200], '...')
    
    if response.message.content:
        print('💬 Response:', response.message.content)
    
    messages.append(response.message)
    
    if response.message.tool_calls:
        print('🔧 Tool calls:', 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('📥 Result:', str(result)[:200], '...')
                # Ergebnis kürzen für begrenzte Kontextlängen
                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} not found', 
                    'tool_name': tool_call.function.name
                })
    else:
        break

Wie gehe ich mit großen Websuchergebnissen in Python um? Kürzen Sie die Ergebnisse, um den Kontextgrenzen zu entsprechen. Der empfohlene Ansatz besteht darin, die Ergebnismetade auf etwa 8000 Zeichen (2000 Token × 4 Zeichen) zu kappen, bevor sie an das Modell übergeben wird.

Fortgeschrittener Suchagent mit Fehlerbehandlung

Hier ist eine erweiterte Version mit besserer Fehlerbehandlung:

from ollama import chat, web_fetch, web_search
import json

class SearchAgent:
    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, question: str) -> str:
        self.messages = [{'role': 'user', 'content': question}]
        
        for iteration 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"Error during chat: {e}"
            
            self.messages.append(response.message)
            
            # Wenn keine Tool-Aufrufe, haben wir eine finale Antwort
            if not response.message.tool_calls:
                return response.message.content or "No response generated"
            
            # Tool-Aufrufe ausführen
            for tool_call in response.message.tool_calls:
                result = self._execute_tool(tool_call)
                self.messages.append({
                    'role': 'tool',
                    'content': result,
                    'tool_name': tool_call.function.name
                })
        
        return "Max iterations reached without final answer"
    
    def _execute_tool(self, tool_call) -> str:
        func_name = tool_call.function.name
        args = tool_call.function.arguments
        
        if func_name not in self.tools:
            return f"Unknown tool: {func_name}"
        
        try:
            result = self.tools[func_name](**args)
            # Für Kontextgrenzen kürzen
            result_str = str(result)
            if len(result_str) > 8000:
                result_str = result_str[:8000] + "... [truncated]"
            return result_str
        except Exception as e:
            return f"Tool error: {e}"

# Verwendung
agent = SearchAgent(model='qwen3:4b')
answer = agent.query("What are the latest features in Ollama?")
print(answer)

Asynchrone Websuche

Kann ich Ollama Python Websuche mit asynchronem Code verwenden? Ja, die Ollama Python-Bibliothek unterstützt asynchrone Operationen. Verwenden Sie AsyncClient für nicht blockierende Websuche- und Abrufoperationen in asynchronen Anwendungen.

import asyncio
from ollama import AsyncClient

async def async_search():
    client = AsyncClient()
    
    # Führen Sie mehrere Suchen parallel aus
    tasks = [
        client.web_search("Ollama features"),
        client.web_search("local LLM tools"),
        client.web_search("AI search agents"),
    ]
    
    results = await asyncio.gather(*tasks)
    
    for i, result in enumerate(results):
        print(f"Search {i + 1}:")
        for r in result.results[:2]:
            print(f"  - {r.title}")
        print()

# Asynchrone Suche ausführen
asyncio.run(async_search())

Asynchroner Suchagent

import asyncio
from ollama import AsyncClient

async def async_research_agent(question: str):
    client = AsyncClient()
    messages = [{'role': 'user', 'content': question}]
    
    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
        
        # Führen Sie Tool-Aufrufe parallel aus
        tool_tasks = []
        for tool_call in response.message.tool_calls:
            if tool_call.function.name == 'web_search':
                task = client.web_search(**tool_call.function.arguments)
            elif tool_call.function.name == 'web_fetch':
                task = client.web_fetch(**tool_call.function.arguments)
            else:
                continue
            tool_tasks.append((tool_call.function.name, task))
        
        # Ergebnisse sammeln
        for tool_name, task in tool_tasks:
            result = await task
            messages.append({
                'role': 'tool',
                'content': str(result)[:8000],
                'tool_name': tool_name
            })

# Ausführen
answer = asyncio.run(async_research_agent("What's new in Python 3.13?"))
print(answer)

Kontextlänge und Leistung

Welche Kontextlänge sollte ich für Python-Suchagenten einstellen? Stellen Sie die Kontextlänge auf ungefähr 32000 Token ein, um eine angemessene Leistung zu erzielen. Suchagenten funktionieren am besten mit voller Kontextlänge, da web_search und web_fetch Tausende von Token zurückgeben können.

from ollama import chat, web_search

# Höheren Kontext für suchlastige Aufgaben einstellen
response = chat(
    model='qwen3:4b',
    messages=[{'role': 'user', 'content': 'Research the latest AI developments'}],
    tools=[web_search],
    options={
        'num_ctx': 32768,  # 32K Kontext
    }
)

MCP-Server-Integration

Ollama stellt einen Python-MCP-Server bereit, der Websuche in jedem MCP-Client ermöglicht. Für einen umfassenden Leitfaden zum Aufbau von MCP-Servern in Python mit Websuche- und Scraping-Funktionen, siehe unser detailliertes Tutorial zu MCP-Server in Python bauen.

Cline-Integration

Konfigurieren Sie MCP-Server in den Cline-Einstellungen:

MCP-Server verwalten → MCP-Server konfigurieren → Hinzufügen:

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

Codex-Integration

Fügen Sie zu ~/.codex/config.toml hinzu:

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

Eigene MCP-Server erstellen

#!/usr/bin/env python3
"""Simple MCP server for Ollama web search."""

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:
    """Search the web for information."""
    results = web_search(query, max_results=max_results)
    
    output = []
    for r in results.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:
    """Fetch the full content of a web page."""
    result = web_fetch(url)
    return f"# {result.title}\n\n{result.content}"

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

Praktische Beispiele

Diese Beispiele demonstrieren reale Anwendungen von Ollamas Websuche-API. Sie können diese Muster erweitern, um komplexere Systeme zu bauen – beispielsweise durch die Kombination von Suchergebnissen mit PDF-Generierung in Python, um Forschungsberichte zu erstellen.

Nachrichten-Zusammenfasser

from ollama import chat, web_search

def summarize_news(topic: str) -> str:
    # Nach aktuellen Nachrichten suchen
    results = web_search(f"{topic} latest news", max_results=5)
    
    # Suchergebnisse für das Modell formatieren
    news_content = "\n\n".join([
        f"**{r.title}**\n{r.content}"
        for r in results.results
    ])
    
    # Das Modell bitten, zusammenzufassen
    response = chat(
        model='qwen3:4b',
        messages=[{
            'role': 'user',
            'content': f"Summarize these news items about {topic}:\n\n{news_content}"
        }]
    )
    
    return response.message.content

summary = summarize_news("artificial intelligence")
print(summary)

Forschungsassistent

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

@dataclass
class ResearchResult:
    question: str
    sources: list
    answer: str

def research(question: str) -> ResearchResult:
    # Nach relevanten Informationen suchen
    search_results = web_search(question, max_results=3)
    
    # Vollständigen Inhalt von Top-Quellen abrufen
    sources = []
    full_content = []
    
    for result in search_results.results[:3]:
        try:
            page = web_fetch(result.url)
            sources.append(result.url)
            full_content.append(f"Source: {result.url}\n{page.content[:2000]}")
        except:
            continue
    
    # Umfassende Antwort generieren
    context = "\n\n---\n\n".join(full_content)
    
    response = chat(
        model='qwen3:4b',
        messages=[{
            'role': 'user',
            'content': f"""Based on the following sources, answer this question: {question}

Sources:
{context}

Provide a comprehensive answer with citations to the sources."""
        }]
    )
    
    return ResearchResult(
        question=question,
        sources=sources,
        answer=response.message.content
    )

# Verwendung
result = research("How does Ollama's new model scheduling work?")
print(f"Question: {result.question}")
print(f"Sources: {result.sources}")
print(f"Answer: {result.answer}")

Empfohlene Modelle

Modell Parameter Am besten für
qwen3:4b 4B Schnelle lokale Suchen
qwen3 8B Allzweck-Agent
gpt-oss Verschiedene Forschungsaufgaben
qwen3:480b-cloud 480B Komplexe Schlussfolgerungen (Cloud)
gpt-oss:120b-cloud 120B Umfangreiche Forschung (Cloud)
deepseek-v3.1-cloud - Fortgeschrittene Analyse (Cloud)

Beste Praktiken

  1. Ergebnisse kürzen: Websuche-Ergebnisse immer auf Kontextgrenzen (~8000 Zeichen) kürzen
  2. Fehlerbehandlung: Tool-Aufrufe in try/except-Blöcke einbetten, um Netzwerkfehler abzufangen
  3. Ratenbegrenzung: Die API-Ratenbegrenzungen von Ollama für die Websuche einhalten
  4. Kontextlänge: Für Suchagenten ~32000 Token verwenden
  5. Asynchron für Skalierung: AsyncClient für parallele Operationen verwenden
  6. Tests: Schreiben Sie Unit-Tests für Ihre Suchagenten, um die Zuverlässigkeit sicherzustellen
  7. Python-Grundlagen: Halten Sie ein Python-Spickzettel bereit für eine schnelle Referenz zu Syntax und gängigen Mustern

Abonnieren

Neue Beiträge zu Systemen, Infrastruktur und KI-Engineering.