Welche Kontextlänge sollte ich für Python-Suchagenten festlegen?

Setzen Sie die Kontextlänge auf etwa 32.000 Tokens für eine vernünftige Leistung. Suchagenten funktionieren am besten mit der vollen Kontextlänge, da web_search und web_fetch Tausende von Tokens zurückgeben können.

Verwendung der Ollama Web Search API in Python

Q: 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.

Q: Was ist der Unterschied zwischen web_search und web_fetch in Ollama Python?

web_search durchsucht das Internet und gibt mehrere Suchergebnisse mit Titeln, URLs und Auszügen zurück. web_fetch holt den vollständigen Inhalt einer bestimmten URL ab und gibt den Seitentitel, den Markdown-Inhalt und die Links zurück.

Q: Welche Python-Modelle eignen sich am besten für Ollama-Suchagenten?

Modelle mit starken Tool-Nutzungsfähigkeiten funktionieren am besten, darunter qwen3, gpt-oss und Cloud-Modelle wie qwen3 480b-cloud und deepseek-v3.1-cloud.

AI-Suchagenten mit Python und Ollama erstellen

Inhaltsverzeichnis

Ollamas Python-Bibliothek umfasst nun native OLlama Websuche-Funktionen. Mit nur wenigen Codezeilen können Sie Ihre lokalen LLMs mit Echtzeitinformationen aus dem Web erweitern, um Halluzinationen zu reduzieren und die Genauigkeit zu verbessern.

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'

Für das Verwalten von Python-Umgebungen und Paketen können Sie uv, einen schnellen Python-Paketmanager, verwenden oder eine virtuelle Umgebung mit venv einrichten, um Ihre Abhängigkeiten isoliert zu halten.

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

Die einfachste Methode, um mit Ollama im Web zu suchen:

import ollama

# Einfache Websuche
response = ollama.web_search("Was ist Ollama?")
print(response)

Ausgabe:

results = [
    {
        "title": "Ollama",
        "url": "https://ollama.com/",
        "content": "Cloud-Modelle sind nun in Ollama verfügbar..."
    },
    {
        "title": "Was ist Ollama? Funktionen, Preise und Anwendungsfälle",
        "url": "https://www.walturn.com/insights/what-is-ollama",
        "content": "Unsere Dienste..."
    },
    {
        "title": "Vollständiger Ollama-Leitfaden: Installation, Nutzung & Code-Beispiele",
        "url": "https://collabnix.com/complete-ollama-guide",
        "content": "Treten Sie unserem Discord-Server bei..."
    }
]

Steuerung der Ergebnisanzahl

import ollama

# Mehr Ergebnisse erhalten
response = ollama.web_search("neueste KI-Nachrichten", max_results=10)

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

Abrufen des vollständigen Seiteninhalts

Was ist der Unterschied zwischen web_search und web_fetch in Ollama Python? web_search durchsucht das Internet und gibt mehrere Suchergebnisse mit Titeln, URLs und Auszügen 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 die weitere Verarbeitung - wenn Sie HTML in anderen Zusammenhängen in Markdown umwandeln müssen, sehen Sie sich unsere Anleitung zur Umwandlung von HTML in Markdown mit Python an.

from ollama import web_fetch

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

Ausgabe:

WebFetchResponse(
    title='Ollama',
    content='[Cloud-Modelle](https://ollama.com/blog/cloud-models) sind nun in Ollama verfügbar\n\n**Chat & erstellen Sie mit offenen Modellen**\n\n[Herunterladen](https://ollama.com/download) [Modelle erkunden](https://ollama.com/models)\n\nVerfügbar für macOS, Windows und Linux',
    links=['https://ollama.com/', 'https://ollama.com/models', 'https://github.com/ollama/ollama']
)

Kombination von Suche und Abruf

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

from ollama import web_search, web_fetch

# Suche nach Informationen
search_results = web_search("Ollama neue Funktionen 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"Titel: {full_content.title}")
    print(f"Inhalt: {full_content.content[:500]}...")
    print(f"Gefundene Links: {len(full_content.links)}")

Aufbau eines Suchagenten

Welche Python-Modelle eignen sich am besten für Ollama-Suchagenten? Modelle mit starken Tool-Use-Fähigkeiten eignen sich am besten, darunter qwen3, gpt-oss und Cloud-Modelle wie qwen3:480b-cloud und deepseek-v3.1-cloud. Für fortgeschrittene Anwendungsfälle, die strukturierte Ausgaben von diesen Modellen erfordern, sehen Sie sich unsere Anleitung zu LLMs mit strukturierten Ausgaben mit Ollama und Qwen3 an.

Zuerst ein fähiges Modell herunterladen:

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': "was ist der neue Engine von ollama"}]

while True:
    response = chat(
        model='qwen3:4b',
        messages=messages,
        tools=[web_search, web_fetch],
        think=True
    )

    if response.message.thinking:
        print('🧠 Denkt:', response.message.thinking[:200], '...')

    if response.message.content:
        print('💬 Antwort:', response.message.content)

    messages.append(response.message)

    if response.message.tool_calls:
        print('🔧 Tool-Aufrufe:', 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('📥 Ergebnis:', str(result)[:200], '...')
                # Ergebnis für begrenzte Kontextlängen kürzen
                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} nicht gefunden',
                    'tool_name': tool_call.function.name
                })
    else:
        break

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

Fortgeschrittener Suchagent mit Fehlerbehandlung

Hier ist eine verbesserte 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"Fehler während des Chats: {e}"

            self.messages.append(response.message)

            # Wenn keine Tool-Aufrufe, haben wir eine endgültige Antwort
            if not response.message.tool_calls:
                return response.message.content or "Keine Antwort generiert"

            # Führen Sie Tool-Aufrufe aus
            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 "Maximale Iterationen erreicht ohne endgültige Antwort"

    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"Unbekanntes Tool: {func_name}"

        try:
            result = self.tools[func_name](**args)
            # Kürzen für Kontextgrenzen
            result_str = str(result)
            if len(result_str) > 8000:
                result_str = result_str[:8000] + "... [gekürzt]"
            return result_str
        except Exception as e:
            return f"Tool-Fehler: {e}"

# Verwendung
agent = SearchAgent(model='qwen3:4b')
answer = agent.query("Was sind die neuesten Funktionen in Ollama?")
print(answer)

Asynchrone Websuche

Kann ich die Ollama Python Websuche mit asynchronem Code verwenden? Ja, die Ollama Python-Bibliothek unterstützt asynchrone Operationen. Verwenden Sie AsyncClient für nicht blockierende Websuch- und Abrufoperationen in asynchronen Anwendungen. Für Leistungsvergleiche zwischen Python und anderen Sprachen in serverlosen Kontexten sehen Sie sich unsere Analyse der AWS Lambda-Leistung in JavaScript, Python und Golang an.

import asyncio
from ollama import AsyncClient

async def async_search():
    client = AsyncClient()

    # Führen Sie mehrere Suchen gleichzeitig aus
    tasks = [
        client.web_search("Ollama-Funktionen"),
        client.web_search("lokale LLM-Tools"),
        client.web_search("KI-Suchagenten"),
    ]

    results = await asyncio.gather(*tasks)

    for i, result in enumerate(results):
        print(f"Suche {i + 1}:")
        for r in result.results[:2]:
            print(f"  - {r.title}")
        print()

# Führen Sie asynchrone Suche aus
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 gleichzeitig 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("Was gibt es Neues 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 etwa 32.000 Tokens für eine vernünftige Leistung ein. Suchagenten funktionieren am besten mit voller Kontextlänge, da web_search und web_fetch tausende Tokens zurückgeben können.

from ollama import chat, web_search

# Höhere Kontext für suchintensive Aufgaben
response = chat(
    model='qwen3:4b',
    messages=[{'role': 'user', 'content': 'Forschen Sie über die neuesten KI-Entwicklungen'}],
    tools=[web_search],
    options={
        'num_ctx': 32768,  # 32K Kontext
    }
)

MCP-Server-Integration

Ollama bietet einen Python-MCP-Server, der Web-Suchen in jedem MCP-Client ermöglicht. Für eine umfassende Anleitung zum Erstellen von MCP-Servern in Python mit Web-Such- und Scraping-Funktionen, siehe unser detailliertes Tutorial zu Building MCP Servers in Python.

Cline-Integration

Konfigurieren Sie MCP-Server in den Cline-Einstellungen:

Verwalten von MCP-Servern → Konfigurieren von MCP-Servern → 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" }

Erstellen Ihres eigenen MCP-Servers

#!/usr/bin/env python3
"""Einfacher MCP-Server für Ollama-Web-Suche."""

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:
    """Suchen Sie im Web nach Informationen."""
    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:
    """Hol die vollständigen Inhalte einer Webseite."""
    result = web_fetch(url)
    return f"# {result.title}\n\n{result.content}"

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

Praktische Beispiele

Diese Beispiele demonstrieren reale Anwendungen der Ollama-Web-Such-API. Sie können diese Muster erweitern, um komplexere Systeme zu erstellen - zum Beispiel die Kombination von Suchergebnissen mit PDF-Erstellung in Python zur Erstellung von Forschungsberichten.

Nachrichten-Zusammenfassung

from ollama import chat, web_search

def summarize_news(topic: str) -> str:
    # Suche nach aktuellen Nachrichten
    results = web_search(f"{topic} neueste Nachrichten", max_results=5)

    # Formatieren der Suchergebnisse für das Modell
    news_content = "\n\n".join([
        f"**{r.title}**\n{r.content}"
        for r in results.results
    ])

    # Bitte das Modell um Zusammenfassung
    response = chat(
        model='qwen3:4b',
        messages=[{
            'role': 'user',
            'content': f"Fassen Sie diese Nachrichteneinträge über {topic} zusammen:\n\n{news_content}"
        }]
    )

    return response.message.content

summary = summarize_news("künstliche Intelligenz")
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:
    # Suche nach relevanten Informationen
    search_results = web_search(question, max_results=3)

    # Holen Sie den vollständigen Inhalt von den Top-Quellen
    sources = []
    full_content = []

    for result in search_results.results[:3]:
        try:
            page = web_fetch(result.url)
            sources.append(result.url)
            full_content.append(f"Quelle: {result.url}\n{page.content[:2000]}")
        except:
            continue

    # Generieren Sie eine umfassende Antwort
    context = "\n\n---\n\n".join(full_content)

    response = chat(
        model='qwen3:4b',
        messages=[{
            'role': 'user',
            'content': f"""Basierend auf den folgenden Quellen, beantworten Sie diese Frage: {question}

Quellen:
{context}

Geben Sie eine umfassende Antwort mit Verweisen auf die Quellen."""
        }]
    )

    return ResearchResult(
        question=question,
        sources=sources,
        answer=response.message.content
    )

# Verwendung
result = research("Wie funktioniert die neue Modellplanung von Ollama?")
print(f"Frage: {result.question}")
print(f"Quellen: {result.sources}")
print(f"Antwort: {result.answer}")

Empfohlene Modelle

Modell	Parameter	Best For
`qwen3:4b`	4B	Schnelle lokale Suchen
`qwen3`	8B	Allgemeiner Agent
`gpt-oss`	Verschiedene	Forschungstätigkeiten
`qwen3:480b-cloud`	480B	Komplexe Schlussfolgerungen (Cloud)
`gpt-oss:120b-cloud`	120B	Langform-Forschung (Cloud)
`deepseek-v3.1-cloud`	-	Fortgeschrittene Analyse (Cloud)

Best Practices

Ergebnisse kürzen: Truncieren Sie immer Web-Ergebnisse, um die Kontextgrenzen (~8000 Zeichen) einzuhalten
Fehlerbehandlung: Umgeben Sie Tool-Aufrufe mit try/except für Netzwerkausfälle
Rate Limiting: Respektieren Sie die API-Rate-Limits von Ollama für Web-Suchen
Kontextlänge: Verwenden Sie ~32000 Tokens für Suchagenten
Async für Skalierbarkeit: Verwenden Sie AsyncClient für gleichzeitige Operationen
Testen: Schreiben Sie Unit Tests für Ihre Suchagenten, um die Zuverlässigkeit sicherzustellen
Python-Grundlagen: Halten Sie ein Python-Cheat-Sheet griffbereit für schnelle Referenzen zu Syntax und häufigen Mustern