Menggunakan Ollama Web Search API dalam Python

Bangun agen pencarian AI dengan Python dan Ollama

Konten Halaman

Perpustakaan Python Ollama sekarang mencakup kemampuan pencarian web OLlama web search. Dengan hanya beberapa baris kode, Anda dapat memperkuat LLM lokal Anda dengan informasi real-time dari web, mengurangi halusinasi dan meningkatkan akurasi.

ruang digital

Memulai

Bagaimana cara menginstal perpustakaan Python Ollama untuk pencarian web? Instal versi 0.6.0 atau lebih tinggi menggunakan pip install 'ollama>=0.6.0'. Versi ini mencakup fungsi web_search dan web_fetch.

pip install 'ollama>=0.6.0'

Untuk mengelola lingkungan dan paket Python, pertimbangkan untuk menggunakan uv, manajer paket Python yang cepat, atau buat lingkungan virtual menggunakan venv untuk memisahkan dependensi Anda.

Buat kunci API dari akun Ollama Anda dan atur sebagai variabel lingkungan:

export OLLAMA_API_KEY="your_api_key"

Di Windows PowerShell:

$env:OLLAMA_API_KEY = "your_api_key"

Pencarian Web Dasar

Cara termudah untuk mencari web dengan Ollama:

import ollama

# Pencarian web sederhana
response = ollama.web_search("Apa itu Ollama?")
print(response)

Output:

results = [
    {
        "title": "Ollama",
        "url": "https://ollama.com/",
        "content": "Model cloud sekarang tersedia di Ollama.."
    },
    {
        "title": "Apa itu Ollama? Fitur, Harga, dan Kasus Penggunaan",
        "url": "https://www.walturn.com/insights/what-is-ollama",
        "content": "Layanan kami.."
    },
    {
        "title": "Panduan Lengkap Ollama: Instalasi, Penggunaan & Contoh Kode",
        "url": "https://collabnix.com/complete-ollama-guide",
        "content": "Bergabung dengan server Discord kami.."
    }
]

Mengontrol Jumlah Hasil

import ollama

# Dapatkan lebih banyak hasil
response = ollama.web_search("berita AI terbaru", max_results=10)

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

Mengambil Konten Halaman Penuh

Apa perbedaan antara web_search dan web_fetch di Ollama Python? web_search melakukan pencarian internet dan mengembalikan beberapa hasil pencarian dengan judul, URL, dan cuplikan. web_fetch mengambil konten penuh dari URL tertentu, mengembalikan judul halaman, konten markdown, dan tautan. Konten markdown yang dikembalikan oleh web_fetch sempurna untuk diproses lebih lanjut—jika Anda perlu mengonversi HTML ke markdown dalam konteks lain, lihat panduan kami tentang mengonversi HTML ke Markdown dengan Python.

from ollama import web_fetch

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

Output:

WebFetchResponse(
    title='Ollama',
    content='[Model cloud](https://ollama.com/blog/cloud-models) sekarang tersedia di Ollama\n\n**Chat & build dengan model terbuka**\n\n[Unduh](https://ollama.com/download) [Eksplorasi model](https://ollama.com/models)\n\nTersedia untuk macOS, Windows, dan Linux',
    links=['https://ollama.com/', 'https://ollama.com/models', 'https://github.com/ollama/ollama']
)

Menggabungkan Pencarian dan Pengambilan

Polanya yang umum adalah mencari terlebih dahulu, lalu mengambil konten penuh dari hasil yang relevan:

from ollama import web_search, web_fetch

# Cari informasi
search_results = web_search("fitur baru Ollama 2025")

# Ambil konten penuh dari hasil pertama
if search_results.results:
    first_url = search_results.results[0].url
    full_content = web_fetch(first_url)
    
    print(f"Judul: {full_content.title}")
    print(f"Konten: {full_content.content[:500]}...")
    print(f"Tautan yang ditemukan: {len(full_content.links)}")

Membangun Agen Pencarian

Model Python mana yang bekerja terbaik untuk agen pencarian Ollama? Model dengan kemampuan penggunaan alat yang kuat bekerja terbaik, termasuk qwen3, gpt-oss, dan model cloud seperti qwen3:480b-cloud dan deepseek-v3.1-cloud. Untuk kasus penggunaan yang lebih lanjut yang memerlukan output terstruktur dari model-model ini, lihat panduan kami tentang LLMs dengan Output Terstruktur menggunakan Ollama dan Qwen3.

Pertama, tarik model yang mampu:

ollama pull qwen3:4b

Agen Pencarian Sederhana

Berikut adalah agen pencarian dasar yang dapat memutuskan secara mandiri kapan harus mencari:

from ollama import chat, web_fetch, web_search

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

messages = [{'role': 'user', 'content': "apa mesin baru ollama"}]

while True:
    response = chat(
        model='qwen3:4b',
        messages=messages,
        tools=[web_search, web_fetch],
        think=True
    )
    
    if response.message.thinking:
        print('🧠 Berpikir:', response.message.thinking[:200], '...')
    
    if response.message.content:
        print('💬 Respons:', response.message.content)
    
    messages.append(response.message)
    
    if response.message.tool_calls:
        print('🔧 Pemanggilan alat:', 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('📥 Hasil:', str(result)[:200], '...')
                # Potong hasil untuk panjang konteks terbatas
                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} tidak ditemukan', 
                    'tool_name': tool_call.function.name
                })
    else:
        break

Bagaimana cara menangani hasil pencarian web besar di Python? Potong hasil agar sesuai dengan batas konteks. Pendekatan yang direkomendasikan adalah memotong string hasil menjadi sekitar 8000 karakter (2000 token × 4 karakter) sebelum dikirim ke model.

Agen Pencarian Lanjutan dengan Penanganan Kesalahan

Berikut adalah versi yang ditingkatkan dengan penanganan kesalahan yang lebih baik:

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"Kesalahan selama chat: {e}"
            
            self.messages.append(response.message)
            
            # Jika tidak ada pemanggilan alat, kami memiliki jawaban akhir
            if not response.message.tool_calls:
                return response.message.content or "Tidak ada respons yang dihasilkan"
            
            # Eksekusi pemanggilan alat
            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 "Iterasi maksimum tercapai tanpa jawaban akhir"
    
    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"Alat tidak dikenal: {func_name}"
        
        try:
            result = self.tools[func_name](**args)
            # Potong untuk batas konteks
            result_str = str(result)
            if len(result_str) > 8000:
                result_str = result_str[:8000] + "... [dipotong]"
            return result_str
        except Exception as e:
            return f"Kesalahan alat: {e}"

# Penggunaan
agent = SearchAgent(model='qwen3:4b')
answer = agent.query("Apa fitur terbaru di Ollama?")
print(answer)

Pencarian Web Async

Apakah saya bisa menggunakan pencarian web Ollama Python dengan kode async? Ya, perpustakaan Python Ollama mendukung operasi async. Gunakan AsyncClient untuk operasi pencarian dan pengambilan web yang tidak menghalangi dalam aplikasi async. Untuk perbandingan kinerja antara Python dan bahasa lain dalam konteks serverless, lihat analisis kami tentang kinerja AWS Lambda di JavaScript, Python, dan Golang.

import asyncio
from ollama import AsyncClient

async def async_search():
    client = AsyncClient()
    
    # Lakukan beberapa pencarian secara bersamaan
    tasks = [
        client.web_search("fitur Ollama"),
        client.web_search("alat LLM lokal"),
        client.web_search("agen pencarian AI"),
    ]
    
    results = await asyncio.gather(*tasks)
    
    for i, result in enumerate(results):
        print(f"Pencarian {i + 1}:")
        for r in result.results[:2]:
            print(f"  - {r.title}")
        print()

# Jalankan pencarian async
asyncio.run(async_search())

Agen Pencarian Async

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
        
        # Eksekusi pemanggilan alat secara bersamaan
        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))
        
        # Kumpulkan hasil
        for tool_name, task in tool_tasks:
            result = await task
            messages.append({
                'role': 'tool',
                'content': str(result)[:8000],
                'tool_name': tool_name
            })

# Jalankan
answer = asyncio.run(async_research_agent("Apa yang baru di Python 3.13?"))
print(answer)

Panjang Konteks dan Kinerja

Panjang konteks apa yang harus saya atur untuk agen pencarian Python? Atur panjang konteks sekitar 32000 token untuk kinerja yang wajar. Agen pencarian bekerja terbaik dengan panjang konteks penuh karena web_search dan web_fetch dapat mengembalikan ribuan token.

from ollama import chat, web_search

# Atur konteks lebih tinggi untuk tugas pencarian berat
response = chat(
    model='qwen3:4b',
    messages=[{'role': 'user', 'content': 'Riset pengembangan AI terbaru'}],
    tools=[web_search],
    options={
        'num_ctx': 32768,  # 32K konteks
    }
)

Integrasi Server MCP

Ollama menyediakan server MCP Python yang memungkinkan pencarian web di setiap klien MCP. Untuk panduan menyeluruh tentang membangun server MCP di Python dengan kemampuan pencarian dan pengambilan web, lihat tutorial terperinci kami tentang Membangun Server MCP di Python.

Integrasi Cline

Konfigurasikan server MCP di pengaturan Cline:

Kelola Server MCP → Konfigurasikan Server MCP → Tambahkan:

{
  "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" }
    }
  }
}

Integrasi Codex

Tambahkan ke ~/.codex/config.toml:

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

Membuat Server MCP Anda Sendiri

#!/usr/bin/env python3
"""Server MCP sederhana untuk pencarian web 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:
    """Cari informasi di web."""
    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:
    """Ambil konten penuh dari halaman web."""
    result = web_fetch(url)
    return f"# {result.title}\n\n{result.content}"

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

Contoh Praktis

Contoh-contoh ini menunjukkan aplikasi dunia nyata dari API pencarian web Ollama. Anda dapat memperluas pola ini untuk membangun sistem yang lebih kompleks—misalnya, menggabungkan hasil pencarian dengan pembuatan PDF di Python untuk membuat laporan penelitian.

Penyaring Berita

from ollama import chat, web_search

def summarize_news(topic: str) -> str:
    # Cari berita terbaru
    results = web_search(f"{topic} berita terbaru", max_results=5)
    
    # Format hasil pencarian untuk model
    news_content = "\n\n".join([
        f"**{r.title}**\n{r.content}"
        for r in results.results
    ])
    
    # Tanyakan model untuk menyaring
    response = chat(
        model='qwen3:4b',
        messages=[{
            'role': 'user',
            'content': f"Ringkaskan item berita tentang {topic}:\n\n{news_content}"
        }]
    )
    
    return response.message.content

summary = summarize_news("kecerdasan buatan")
print(summary)

Asisten Penelitian

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:
    # Cari informasi yang relevan
    search_results = web_search(question, max_results=3)
    
    # Ambil konten penuh dari sumber teratas
    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
    
    # Buat jawaban komprehensif
    context = "\n\n---\n\n".join(full_content)
    
    response = chat(
        model='qwen3:4b',
        messages=[{
            'role': 'user',
            'content': f"""Berdasarkan sumber berikut, jawab pertanyaan ini: {question}

Sumber:
{context}

Berikan jawaban yang komprehensif dengan sitasi ke sumber-sumber tersebut."""
        }]
    )
    
    return ResearchResult(
        question=question,
        sources=sources,
        answer=response.message.content
    )

# Penggunaan
result = research("Bagaimana jadwal model baru Ollama bekerja?")
print(f"Pertanyaan: {result.question}")
print(f"Sumber: {result.sources}")
print(f"Jawaban: {result.answer}")

Model yang Direkomendasikan

Model Parameter Terbaik Untuk
qwen3:4b 4B Pencarian lokal cepat
qwen3 8B Agen umum
gpt-oss Berbagai Tugas penelitian
qwen3:480b-cloud 480B Penalaran kompleks (cloud)
gpt-oss:120b-cloud 120B Penelitian berbentuk panjang (cloud)
deepseek-v3.1-cloud - Analisis lanjutan (cloud)

Praktik Terbaik

  1. Potong Hasil: Selalu potong hasil web untuk sesuai dengan batas konteks (~8000 karakter)
  2. Penanganan Kesalahan: Bungkus pemanggilan alat dalam try/except untuk kegagalan jaringan
  3. Pembatasan Tingkat: Hormati batas tingkat API Ollama untuk pencarian web
  4. Panjang Konteks: Gunakan ~32000 token untuk agen pencarian
  5. Async untuk Skala: Gunakan AsyncClient untuk operasi bersamaan
  6. Pengujian: Tulis tes unit untuk agen pencarian Anda untuk memastikan keandalan
  7. Dasar Python: Simpan lembar kecil Python untuk referensi cepat tentang sintaks dan pola umum

Tautan Berguna