Użycie interfejsu API Ollama Web Search w Pythonie

Tworzenie agentów wyszukiwania AI za pomocą Pythona i Ollama

Page content

Biblioteka Pythona Ollama zawiera teraz natywne możliwości wyszukiwania w sieci OLlama web search. Dzięki kilku linijkom kodu możesz wzbogacić swoje lokalne modele językowe o rzeczywiste informacje z sieci, zmniejszając halucynacje i poprawiając dokładność.

przestrzeń cyfrowa

Rozpoczęcie pracy

Jak zainstalować bibliotekę Pythona Ollama dla wyszukiwania w sieci? Zainstaluj wersję 0.6.0 lub nowszą za pomocą pip install 'ollama>=0.6.0'. Ta wersja zawiera funkcje web_search i web_fetch.

pip install 'ollama>=0.6.0'

Dla zarządzania środowiskami i pakietami Pythona rozważ użycie uv, szybkiego menedżera pakietów Pythona, lub ustaw środowisko wirtualne za pomocą venv, aby oddzielić swoje zależności.

Utwórz klucz API z Twojego konta Ollama i ustaw go jako zmienną środowiskową:

export OLLAMA_API_KEY="your_api_key"

Na Windows PowerShell:

$env:OLLAMA_API_KEY = "your_api_key"

Podstawowe wyszukiwanie w sieci

Najprostszy sposób wyszukiwania w sieci za pomocą Ollama:

import ollama

# Proste wyszukiwanie w sieci
response = ollama.web_search("Co to jest Ollama?")
print(response)

Wynik:

results = [
    {
        "title": "Ollama",
        "url": "https://ollama.com/",
        "content": "Modele chmurowe są teraz dostępne w Ollama..."
    },
    {
        "title": "Co to jest Ollama? Funkcje, Ceny i Przypadki Użycia",
        "url": "https://www.walturn.com/insights/what-is-ollama",
        "content": "Nasze usługi..."
    },
    {
        "title": "Kompletny przewodnik po Ollama: Instalacja, Użycie i Przykłady Kodu",
        "url": "https://collabnix.com/complete-ollama-guide",
        "content": "Dołącz do naszego serwera Discord..."
    }
]

Kontrolowanie liczby wyników

import ollama

# Pobierz więcej wyników
response = ollama.web_search("najnowsze wiadomości AI", max_results=10)

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

Pobieranie pełnego treści strony

Co to jest web_search vs web_fetch w Pythonie Ollama? web_search wyszukuje internet i zwraca wiele wyników wyszukiwania z tytułów, adresów URL i fragmentów. web_fetch pobiera pełną treść konkretnego adresu URL, zwracając tytuł strony, treść w formacie markdown i linki. Treść markdown zwracana przez web_fetch jest idealna do dalszego przetwarzania — jeśli potrzebujesz konwersji HTML na markdown w innych kontekstach, zobacz nasz przewodnik po konwersji HTML na Markdown w Pythonie.

from ollama import web_fetch

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

Wynik:

WebFetchResponse(
    title='Ollama',
    content='[Modele chmurowe](https://ollama.com/blog/cloud-models) są teraz dostępne w Ollama\n\n**Chatuj i buduj z otwartymi modelami**\n\n[Pobierz](https://ollama.com/download) [Eksploruj modele](https://ollama.com/models)\n\nDostępne dla macOS, Windows i Linux',
    links=['https://ollama.com/', 'https://ollama.com/models', 'https://github.com/ollama/ollama']
)

Łączenie wyszukiwania i pobierania

Typowym wzorcem jest najpierw wyszukiwanie, a następnie pobieranie pełnej treści z odpowiednich wyników:

from ollama import web_search, web_fetch

# Wyszukaj informacje
search_results = web_search("nowe funkcje Ollama 2025")

# Pobierz pełną treść z pierwszego wyniku
if search_results.results:
    first_url = search_results.results[0].url
    full_content = web_fetch(first_url)
    
    print(f"Nazwa: {full_content.title}")
    print(f"Treść: {full_content.content[:500]}...")
    print(f"Znalezione linki: {len(full_content.links)}")

Budowanie agenta wyszukiwania

Które modele Pythona najlepiej działają dla agentów wyszukiwania Ollama? Modele z silnymi możliwościami użycia narzędzi działają najlepiej, w tym qwen3, gpt-oss oraz modele chmurowe takie jak qwen3:480b-cloud i deepseek-v3.1-cloud. Dla bardziej zaawansowanych przypadków użycia wymagających strukturalnych wyników z tych modeli, zobacz nasz przewodnik po LLM z strukturalnymi wynikami za pomocą Ollama i Qwen3.

Najpierw pobierz kompetentny model:

ollama pull qwen3:4b

Prosty agent wyszukiwania

Oto podstawowy agent wyszukiwania, który może samodzielnie decydować, kiedy wyszukiwać:

from ollama import chat, web_fetch, web_search

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

messages = [{'role': 'user', 'content': "co to jest nowy silnik Ollama"}]

while True:
    response = chat(
        model='qwen3:4b',
        messages=messages,
        tools=[web_search, web_fetch],
        think=True
    )
    
    if response.message.thinking:
        print('🧠 Myślenie:', response.message.thinking[:200], '...')
    
    if response.message.content:
        print('💬 Odpowiedź:', response.message.content)
    
    messages.append(response.message)
    
    if response.message.tool_calls:
        print('🔧 Wywołania narzędzi:', 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('📥 Wynik:', str(result)[:200], '...')
                # Przycinaj wynik, aby zmieścić się w ograniczenia długości kontekstu
                messages.append({
                    'role': 'tool', 
                    'content': str(result)[:2000 * 4], 
                    'tool_name': tool_call.function.name
                })
            else:
                messages.append({
                    'role': 'tool', 
                    'content': f'Narzędzie {tool_call.function.name} nie znaleziono', 
                    'tool_name': tool_call.function.name
                })
    else:
        break

Jak radzić sobie z dużymi wynikami wyszukiwania w Pythonie? Przycinaj wyniki, aby zmieścić się w ograniczenia długości kontekstu. Zalecany sposób to przycięcie łańcucha wyników do około 8000 znaków (2000 tokenów × 4 znaki) przed przekazaniem do modelu.

Zaawansowany agent wyszukiwania z obsługą błędów

Oto wzmocniona wersja z lepszą obsługą błędów:

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"Błąd podczas chatu: {e}"
            
            self.messages.append(response.message)
            
            # Jeśli nie ma wywołań narzędzi, mamy gotową odpowiedź
            if not response.message.tool_calls:
                return response.message.content or "Nie wygenerowano odpowiedzi"
            
            # Wykonaj wywołania narzędzi
            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 "Przekroczono maksymalną liczbę iteracji bez końcowej odpowiedzi"
    
    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"Nierozpoznane narzędzie: {func_name}"
        
        try:
            result = self.tools[func_name](**args)
            # Przycinaj dla ograniczeń długości kontekstu
            result_str = str(result)
            if len(result_str) > 8000:
                result_str = result_str[:8000] + "... [przycięte]"
            return result_str
        except Exception as e:
            return f"Błąd narzędzia: {e}"

# Użycie
agent = SearchAgent(model='qwen3:4b')
answer = agent.query("Jakie są najnowsze funkcje w Ollama?")
print(answer)

Asynchroniczne wyszukiwanie w sieci

Czy mogę używać asynchronicznych operacji wyszukiwania w sieci w bibliotece Pythona Ollama? Tak, biblioteka Pythona Ollama obsługuje operacje asynchroniczne. Użyj AsyncClient dla nieblokujących operacji wyszukiwania i pobierania w aplikacjach asynchronicznych. Dla porównań wydajności między Pythonem a innymi językami w kontekście bezserwerowym, zobacz naszą analizę wydajności AWS Lambda w języku JavaScript, Python i Golang.

import asyncio
from ollama import AsyncClient

async def async_search():
    client = AsyncClient()
    
    # Wykonaj wiele wyszukiwań równolegle
    tasks = [
        client.web_search("funkcje Ollama"),
        client.web_search("lokalne narzędzia LLM"),
        client.web_search("agenta AI wyszukiwania"),
    ]
    
    results = await asyncio.gather(*tasks)
    
    for i, result in enumerate(results):
        print(f"Wyszukiwanie {i + 1}:")
        for r in result.results[:2]:
            print(f"  - {r.title}")
        print()

# Uruchom asynchroniczne wyszukiwanie
asyncio.run(async_search())

Asynchroniczny agent wyszukiwania

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
        
        # Wykonaj wywołania narzędzi równolegle
        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))
        
        # Zbierz wyniki
        for tool_name, task in tool_tasks:
            result = await task
            messages.append({
                'role': 'tool',
                'content': str(result)[:8000],
                'tool_name': tool_name
            })

# Uruchom
answer = asyncio.run(async_research_agent("Co nowego w Pythonie 3.13?"))
print(answer)

Długość kontekstu i wydajność

Jaka długość kontekstu powinna być ustawiona dla agentów wyszukiwania w Pythonie? Ustaw długość kontekstu na około 32000 tokenów dla rozsądnego poziomu wydajności. Agentowie wyszukiwania działają najlepiej z pełną długością kontekstu, ponieważ web_search i web_fetch mogą zwracać tysiące tokenów.

from ollama import chat, web_search

# Ustaw wyższy kontekst dla zadań intensywnie korzystających z wyszukiwania
response = chat(
    model='qwen3:4b',
    messages=[{'role': 'user', 'content': 'Badaj najnowsze rozwinięcia w dziedzinie AI'}],
    tools=[web_search],
    options={
        'num_ctx': 32768,  # 32K kontekst
    }
)

Integracja z serwerem MCP

Ollama oferuje serwer Pythona MCP, który umożliwia wyszukiwanie w sieci w dowolnym kliencie MCP. Dla kompletnego przewodnika dotyczącego budowania serwerów MCP w Pythonie z funkcjami wyszukiwania w sieci i skrapowania, zobacz nasz szczegółowy tutorial na temat budowania serwerów MCP w Pythonie.

Integracja z Cline

Skonfiguruj serwery MCP w ustawieniach Cline:

Zarządzaj serwerami MCP → Skonfiguruj serwery MCP → Dodaj:

{
  "mcpServers": {
    "web_search_and_fetch": {
      "type": "stdio",
      "command": "uv",
      "args": ["run", "ścieżka/do/web-search-mcp.py"],
      "env": { "OLLAMA_API_KEY": "twoj_klucz_api_tutaj" }
    }
  }
}

Integracja z Codex

Dodaj do ~/.codex/config.toml:

[mcp_servers.web_search]
command = "uv"
args = ["run", "ścieżka/do/web-search-mcp.py"]
env = { "OLLAMA_API_KEY" = "twoj_klucz_api_tutaj" }

Tworzenie własnego serwera MCP

#!/usr/bin/env python3
"""Prosty serwer MCP dla wyszukiwania w sieci Ollama."""

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:
    """Wyszukaj informacje w sieci."""
    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:
    """Pobierz pełną treść strony sieciowej."""
    result = web_fetch(url)
    return f"# {result.title}\n\n{result.content}"

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

Przykłady praktyczne

Te przykłady demonstrują rzeczywiste zastosowania API wyszukiwania w sieci Ollama. Możesz rozszerzyć te wzorce, aby stworzyć bardziej złożone systemy — na przykład łącząc wyniki wyszukiwania z generowaniem PDF w Pythonie, aby tworzyć raporty badawcze.

Sumaryzator wiadomości

from ollama import chat, web_search

def summarize_news(topic: str) -> str:
    # Wyszukaj najnowsze wiadomości
    results = web_search(f"{topic} najnowsze wiadomości", max_results=5)
    
    # Sformatuj wyniki wyszukiwania dla modelu
    news_content = "\n\n".join([
        f"**{r.title}**\n{r.content}"
        for r in results.results
    ])
    
    # Zapytaj model, aby podsumować
    response = chat(
        model='qwen3:4b',
        messages=[{
            'role': 'user',
            'content': f"Podsumuj te wiadomości dotyczące {topic}:\n\n{news_content}"
        }]
    )
    
    return response.message.content

summary = summarize_news("inteligencja sztuczna")
print(summary)

Asystent badawczy

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:
    # Wyszukaj odpowiednie informacje
    search_results = web_search(question, max_results=3)
    
    # Pobierz pełną treść z najlepszych źródeł
    sources = []
    full_content = []
    
    for result in search_results.results[:3]:
        try:
            page = web_fetch(result.url)
            sources.append(result.url)
            full_content.append(f"Źródło: {result.url}\n{page.content[:2000]}")
        except:
            continue
    
    # Generuj komprehensywną odpowiedź
    context = "\n\n---\n\n".join(full_content)
    
    response = chat(
        model='qwen3:4b',
        messages=[{
            'role': 'user',
            'content': f"""Na podstawie poniższych źródeł, odpowiedz na to pytanie: {question}

Źródła:
{context}

Zaproponuj szczegółową odpowiedź z cytowaniami źródeł."""
        }]
    )
    
    return ResearchResult(
        question=question,
        sources=sources,
        answer=response.message.content
    )

# Użycie
result = research("Jak działa nowy system planowania modeli w Ollama?")
print(f"Pytanie: {result.question}")
print(f"Źródła: {result.sources}")
print(f"Odpowiedź: {result.answer}")

Zalecane modele

Model Parametry Najlepsze do
qwen3:4b 4B Szybkie lokalne wyszukiwania
qwen3 8B Ogólnego przeznaczenia
gpt-oss Wielu Zadań badawczych
qwen3:480b-cloud 480B Złożone rozumowanie (chmura)
gpt-oss:120b-cloud 120B Długie formy badawcze (chmura)
deepseek-v3.1-cloud - Zaawansowane analizy (chmura)

Praktyczne wskazówki

  1. Przycinaj wyniki: Zawsze przycinaj wyniki sieciowe, aby zmieścić się w ograniczenia długości kontekstu (~8000 znaków)
  2. Obsługa błędów: Obkłuj wywołania narzędzi try/except dla błędów sieciowych
  3. Ograniczanie stawki: Szanuj limity stawki API Ollama dla wyszukiwania w sieci
  4. Długość kontekstu: Używaj ~32000 tokenów dla agentów wyszukiwania
  5. Asynchroniczne dla skali: Używaj AsyncClient dla operacji równoległych
  6. Testowanie: Pisz testy jednostkowe dla swoich agentów wyszukiwania, aby zapewnić niezawodność
  7. Podstawy Pythona: Zachowaj przykładowy arkusz Pythona pod ręką jako szybki przewodnik po składni i typowych wzorcach

Przydatne linki