Vilken kontextlängd bör jag ställa in för Python-sökningsagenter?

Ange kontextlängden till cirka 32 000 token för rimlig prestanda. Sökagenter fungerar bäst med full kontextlängd, eftersom web_search och web_fetch kan returnera tusentals token.

Använda Ollama Web Search API i Python

Q: Hur installerar jag Ollama Python-biblioteket för webbsökning?

Installera version 0.6.0 eller högre med pip install 'ollama>=0.6.0' . Denna version inkluderar funktionerna web_search och web_fetch.

Q: Vad är skillnaden mellan web_search och web_fetch i Ollama Python?

web_search frågar internet och returnerar flera sökträffar med titlar, webbadresser och utdrag. web_fetch hämtar fullständigt innehåll från en specifik webbadress, returnerar sidtiteln, markdown-innehåll och länkar.

Q: Hur hanterar jag stora webbsökningsresultat i Python?

Trunkera resultat för att passa kontextbegränsningar. Det rekommenderade tillvägagångssättet är att dela upp resultatsträngen till cirka 8000 tecken (2000 token x 4 tecken) innan den skickas till modellen.

Bygg AI-söklägenheter med Python och Ollama

Sidinnehåll

Ollamas Python-bibliotek inkluderar nu inbyggda OLlama web search-funktioner. Med bara några rader kod kan du komplettera dina lokala LLMs med realtidssökningar på webben, vilket minskar hallucinationer och förbättrar noggrannheten.

Kom igång

Hur installerar jag Ollama Python-biblioteket för webbsökning? Installera version 0.6.0 eller högre med pip install 'ollama>=0.6.0'. Denna version inkluderar funktionerna web_search och web_fetch.

pip install 'ollama>=0.6.0'

För hantering av Python-miljöer och paket, överväg att använda uv, en snabb Python-pakethanterare, eller sätt upp en virtuell miljö med venv för att hålla dina beroenden isolerade.

Skapa en API-nyckel från ditt Ollama-konto och ställ in den som en miljövariabel:

export OLLAMA_API_KEY="your_api_key"

På Windows PowerShell:

$env:OLLAMA_API_KEY = "your_api_key"

Grundläggande webbsökning

Det enklaste sättet att söka på webben med Ollama:

import ollama

# Enkel webbsökning
response = ollama.web_search("Vad är Ollama?")
print(response)

Utdata:

results = [
    {
        "title": "Ollama",
        "url": "https://ollama.com/",
        "content": "Cloud models are now available in Ollama..."
    },
    {
        "title": "Vad är Ollama? Funktioner, prissättning och användningsområden",
        "url": "https://www.walturn.com/insights/what-is-ollama",
        "content": "Våra tjänster..."
    },
    {
        "title": "Komplett Ollama-guide: Installation, användning & kodexempel",
        "url": "https://collabnix.com/complete-ollama-guide",
        "content": "Gå med i vår Discord-server..."
    }
]

Kontrollera antalet resultat

import ollama

# Få fler resultat
response = ollama.web_search("senaste AI-nyheter", max_results=10)

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

Hämta fullständigt sidinnehåll

Vad är skillnaden mellan web_search och web_fetch i Ollama Python? web_search söker på internet och returnerar flera sökträffar med titlar, URL:er och utdrag. web_fetch hämtar fullständigt innehåll från en specifik URL och returnerar sidtiteln, markdown-innehåll och länkar. Det markdown-innehåll som returneras av web_fetch är perfekt för vidare bearbetning - om du behöver konvertera HTML till markdown i andra sammanhang, se vår guide om konvertering av HTML till Markdown med Python.

from ollama import web_fetch

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

Utdata:

WebFetchResponse(
    title='Ollama',
    content='[Cloud models](https://ollama.com/blog/cloud-models) är nu tillgängliga i Ollama\n\n**Chatta & bygg med öppna modeller**\n\n[Ladda ner](https://ollama.com/download) [Utforska modeller](https://ollama.com/models)\n\nTillgängligt för macOS, Windows och Linux',
    links=['https://ollama.com/', 'https://ollama.com/models', 'https://github.com/ollama/ollama']
)

Kombinera sökning och hämtning

En vanlig mönster är att först söka, sedan hämta fullständigt innehåll från relevanta resultat:

from ollama import web_search, web_fetch

# Sök efter information
search_results = web_search("Ollamas nya funktioner 2025")

# Hämta fullständigt innehåll från första resultatet
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"Innehåll: {full_content.content[:500]}...")
    print(f"Hittade länkar: {len(full_content.links)}")

Bygga en sökgent

Vilka Python-modeller fungerar bäst för Ollama-sökgenter? Modeller med starka verktygsanvändningsförmågor fungerar bäst, inklusive qwen3, gpt-oss och molnmodeller som qwen3:480b-cloud och deepseek-v3.1-cloud. För mer avancerade användningsområden som kräver strukturerade utdata från dessa modeller, se vår guide om LLMs med strukturerad utdata med Ollama och Qwen3.

Först, ladda ner en kapabel modell:

ollama pull qwen3:4b

Enkel sökgent

Här är en grundläggande sökgent som kan autonomt bestämma när den ska söka:

from ollama import chat, web_fetch, web_search

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

messages = [{'role': 'user', 'content': "vad är ollamas nya motor"}]

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

    if response.message.thinking:
        print('🧠 Tänkande:', response.message.thinking[:200], '...')

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

    messages.append(response.message)

    if response.message.tool_calls:
        print('🔧 Verktygsanrop:', 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('📥 Resultat:', str(result)[:200], '...')
                # Avkorta resultat för begränsade kontextlängder
                messages.append({
                    'role': 'tool',
                    'content': str(result)[:2000 * 4],
                    'tool_name': tool_call.function.name
                })
            else:
                messages.append({
                    'role': 'tool',
                    'content': f'Verktyget {tool_call.function.name} hittades inte',
                    'tool_name': tool_call.function.name
                })
    else:
        break

Hur hanterar jag stora webbsökningsresultat i Python? Avkorta resultat för att passa kontextbegränsningarna. Det rekommenderade tillvägagångssättet är att skära av resultatsträngen till cirka 8000 tecken (2000 token × 4 tecken) innan du skickar den till modellen.

Avancerad sökgent med felhantering

Här är en förbättrad version med bättre felhantering:

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"Fel under chatt: {e}"

            self.messages.append(response.message)

            # Om inga verktygsanrop, har vi ett slutgiltigt svar
            if not response.message.tool_calls:
                return response.message.content or "Inga svar genererades"

            # Kör verktygsanrop
            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 antal iterationer nåddes utan slutgiltigt svar"

    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"Okänt verktyg: {func_name}"

        try:
            result = self.tools[func_name](**args)
            # Avkorta för kontextbegränsningar
            result_str = str(result)
            if len(result_str) > 8000:
                result_str = result_str[:8000] + "... [avkortat]"
            return result_str
        except Exception as e:
            return f"Verktygsfel: {e}"

# Användning
agent = SearchAgent(model='qwen3:4b')
answer = agent.query("Vilka är de senaste funktionerna i Ollama?")
print(answer)

Asynkron webbsökning

Kan jag använda Ollama Python webbsökning med asynkron kod? Ja, Ollama Python-biblioteket stöder asynkrona operationer. Använd AsyncClient för icke-blockerande webbsökningar och hämtningar i asynkrona applikationer. För prestandajämförelser mellan Python och andra språk i serverlösa sammanhang, se vår analys av AWS Lambda-prestanda för JavaScript, Python och Golang.

import asyncio
from ollama import AsyncClient

async def async_search():
    client = AsyncClient()

    # Utför flera sökningar samtidigt
    tasks = [
        client.web_search("Ollama funktioner"),
        client.web_search("lokala LLM-verktyg"),
        client.web_search("AI-sökgenter"),
    ]

    results = await asyncio.gather(*tasks)

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

# Kör asynkron sökning
asyncio.run(async_search())

Asynkron sökgent

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

        # Kör verktygsanrop samtidigt
        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))

        # Samla resultat
        for tool_name, task in tool_tasks:
            result = await task
            messages.append({
                'role': 'tool',
                'content': str(result)[:8000],
                'tool_name': tool_name
            })

# Kör
answer = asyncio.run(async_research_agent("Vad är nytt i Python 3.13?"))
print(answer)

Kontextlängd och prestanda

Vilken kontextlängd bör jag ställa in för Python-sökmotorer? Ställ in kontextlängden till cirka 32 000 token för rimlig prestanda. Sökmotorer fungerar bäst med full kontextlängd eftersom web_search och web_fetch kan returnera tusentals token.

from ollama import chat, web_search

# Ställ in högre kontext för söktunga uppgifter
response = chat(
    model='qwen3:4b',
    messages=[{'role': 'user', 'content': 'Forskning om de senaste AI-utvecklingarna'}],
    tools=[web_search],
    options={
        'num_ctx': 32768,  # 32K kontext
    }
)

MCP Server Integration

Ollama erbjuder en Python MCP-server som möjliggör webbsökning i vilken MCP-klient som helst. För en omfattande guide om att bygga MCP-servrar i Python med webbsöknings- och skrapningsfunktioner, se vår detaljerade tutorial om Att bygga MCP-servrar i Python.

Cline Integration

Konfigurera MCP-servrar i Cline-inställningar:

Hantera MCP-servrar → Konfigurera MCP-servrar → Lägg till:

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

Codex Integration

Lägg till i ~/.codex/config.toml:

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

Att skapa din egen MCP-server

#!/usr/bin/env python3
"""Enkel MCP-server för Ollama webbsökning."""

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:
    """Sök på webben efter 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:
    """Hämta fullständigt innehåll från en webbsida."""
    result = web_fetch(url)
    return f"# {result.title}\n\n{result.content}"

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

Praktiska exempel

Dessa exempel demonstrerar verkliga tillämpningar av Ollamas webbsöknings-API. Du kan utöka dessa mönster för att bygga mer komplexa system - till exempel kombinera sökträffar med PDF-generering i Python för att skapa forskningsrapporter.

Nyhets sammanfattare

from ollama import chat, web_search

def summarize_news(topic: str) -> str:
    # Sök efter senaste nyheter
    results = web_search(f"{topic} senaste nyheter", max_results=5)

    # Formatera sökträffar för modellen
    news_content = "\n\n".join([
        f"**{r.title}**\n{r.content}"
        for r in results.results
    ])

    # Be modellen att sammanfatta
    response = chat(
        model='qwen3:4b',
        messages=[{
            'role': 'user',
            'content': f"Sammanfatta dessa nyhetsartiklar om {topic}:\n\n{news_content}"
        }]
    )

    return response.message.content

summary = summarize_news("konstig intelligens")
print(summary)

Forskningsassistent

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:
    # Sök efter relevant information
    search_results = web_search(question, max_results=3)

    # Hämta fullständigt innehåll från toppkällor
    sources = []
    full_content = []

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

    # Generera en omfattande svar
    context = "\n\n---\n\n".join(full_content)

    response = chat(
        model='qwen3:4b',
        messages=[{
            'role': 'user',
            'content': f"""Baserat på följande källor, svara på denna fråga: {question}

Källor:
{context}

Ge ett omfattande svar med hänvisningar till källorna."""
        }]
    )

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

# Användning
result = research("Hur fungerar Ollamas nya modellplanering?")
print(f"Fråga: {result.question}")
print(f"Källor: {result.sources}")
print(f"Svar: {result.answer}")

Rekommenderade modeller

Modell	Parametrar	Bäst för
`qwen3:4b`	4B	Snabba lokala sökningar
`qwen3`	8B	Allmänt ändamål
`gpt-oss`	Olika	Forskningsuppgifter
`qwen3:480b-cloud`	480B	Komplex resonemang (moln)
`gpt-oss:120b-cloud`	120B	Långformad forskning (moln)
`deepseek-v3.1-cloud`	-	Avancerad analys (moln)

Bäst praxis

Trunkera resultat: Trunkera alltid webbresultat för att passa kontextbegränsningarna (~8000 tecken)
Felhantering: Wrapa verktygsanrop i try/except för nätverksfel
Rate limiting: Respektera Ollamas API-ratebegränsningar för webbsökning
Kontextlängd: Använd ~32 000 token för sökmotorer
Async för skalbarhet: Använd AsyncClient för parallella operationer
Testning: Skriv enhetstester för dina sökmotorer för att säkerställa pålitlighet
Python grundläggande: Håll en Python snabbguide till hands för snabb referens till syntax och vanliga mönster