---
title: "API Web Search Ollama: Guida Completa per Arricchire i LLM"
date: "2026-05-28"
category: "Intelligenza Artificiale"
tags: ["javascript", "llm", "ollama", "python", "web-search-api"]
author: "Giuseppe Carruezzo"
description: "Scopri la nuova API di web search di Ollama per arricchire i modelli linguistici con informazioni aggiornate dal web. Guide Python e JavaScript."
source: "https://ainsights.it/blog/api-web-search-ollama-llm"
---

# API Web Search Ollama: Guida Completa per Arricchire i LLM

![API Web Search Ollama: Guida Completa per Arricchire i LLM](/blogai/backend/uploads/6a18c9e265843.webp)

Ollama introduce una nuova API di web search che permette di arricchire i modelli linguistici con informazioni aggiornate dal web, riducendo le allucinazioni e migliorando la precisione delle risposte. Questa funzionalità è disponibile sia tramite REST API che attraverso librerie Python e JavaScript.

## Introduzione

[![Web search di Ollama](/blogai/backend/uploads/6a18c9e459a50.webp)](https://ollama.com/signup)

Una nuova API di web search è ora disponibile in Ollama. La piattaforma offre un generoso piano gratuito di ricerche web per uso individuale, mentre limiti più elevati sono disponibili tramite [Ollama Cloud](https://ollama.com/cloud).

Questa capacità di ricerca web può aumentare i modelli linguistici con le informazioni più recenti dal web per ridurre le allucinazioni e migliorare l'accuratezza.

Il servizio di web search è fornito come REST API con integrazioni tool più profonde nelle librerie Python e JavaScript di Ollama. Questo abilita anche modelli come `gpt-oss` di OpenAI a condurre attività di ricerca di lunga durata.

## Come iniziare

Crea una API key dal tuo [account Ollama](https://ollama.com/settings/keys).

```bash
export OLLAMA_API_KEY="your_api_key"
```

### cURL

```bash
curl https://ollama.com/api/web_search \
  --header "Authorization: Bearer $OLLAMA_API_KEY" \
  -d '{
    "query": "what is ollama?"
  }'
```

**Esempio di output**

```json
{
  "results": [
    {
      "title": "Ollama",
      "url": "https://ollama.com/",
      "content": "Cloud models are now available..."
    },
    {
      "title": "What is Ollama? Introduction to the AI model management tool",
      "url": "https://www.hostinger.com/tutorials/what-is-ollama",
      "content": "Ariffud M. 6min Read..."
    },
    {
      "title": "Ollama Explained: Transforming AI Accessibility and Language ...",
      "url": "https://www.geeksforgeeks.org/artificial-intelligence/ollama-explained-transforming-ai-accessibility-and-language-processing/",
      "content": "Data Science Data Science Projects Data Analysis..."
    }
  ]
}
```

### Python

Installa ed esegui la libreria Python di Ollama:

```bash
pip install 'ollama>=0.6.0'
```

Effettua poi una richiesta usando `ollama.web_search`:

```python
import ollama
response = ollama.web_search("What is Ollama?")
print(response)
```

**Esempio di output**

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

### JavaScript

Installa ed esegui la libreria JavaScript di Ollama:

```bash
npm install 'ollama>=0.6.0'
```

```javascript
import { Ollama } from "ollama";

const client = new Ollama();
const results = await client.webSearch({ query: "what is ollama?" });
console.log(JSON.stringify(results, null, 2));
```

**Esempio di output**

```javascript
{
  "results": [
    {
      "title": "Ollama",
      "url": "https://ollama.com/",
      "content": "Cloud models are now available..."
    },
    {
      "title": "What is Ollama? Introduction to the AI model management tool",
      "url": "https://www.hostinger.com/tutorials/what-is-ollama",
      "content": "Ollama is an open-source tool..."
    },
    {
      "title": "Ollama Explained: Transforming AI Accessibility and Language Processing",
      "url": "https://www.geeksforgeeks.org/artificial-intelligence/ollama-explained-transforming-ai-accessibility-and-language-processing/",
      "content": "Ollama is a groundbreaking..."
    }
  ]
}
```

## Costruire un agente di ricerca

Usa la web search di Ollama come strumento per costruire un mini agente di ricerca.

L'esempio utilizza il modello Qwen 3 di Alibaba con 4 miliardi di parametri.

```bash
ollama pull qwen3:4b
```

```python
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)
  if response.message.content:
    print('Content: ', 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]+'...')
        # Result is truncated for limited context lengths
        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
```

**Risultato**

```plaintext
Thinking:  Okay, the user is asking about Ollama's new engine. I need to figure out what they're referring to. Ollama is a company that develops large language models, so maybe they've released a new model or an updated version of their existing engine...

Tool calls:  [ToolCall(function=Function(name='web_search', arguments={'max_results': 3, 'query': 'Ollama new engine'}))]
Result:  results=[WebSearchResult(content='# New model scheduling\n\n## September 23, 2025\n\nOllama now includes a significantly improved model scheduling system. Ahead of running a model, Ollama's new engine...

Thinking:  Okay, the user asked about Ollama's new engine. Let me look at the search results.

First result is from September 23, 2025, talking about new model scheduling. It mentions improved memory management, reduced crashes, better GPU utilization, and multi-GPU performance. Examples show speed improvements and accurate memory reporting. Supported models include gemma3, llama4, qwen3, etc...

Content:  Ollama has introduced two key updates to its engine, both released in 2025:

1. **Enhanced Model Scheduling (September 23, 2025)**
   - **Precision Memory Management**: Exact memory allocation reduces out-of-memory crashes and optimizes GPU utilization.
   - **Performance Gains**: Examples show significant speed improvements (e.g., 85.54 tokens/s vs 52.02 tokens/s) and full GPU layer utilization.
   - **Multi-GPU Support**: Improved efficiency across multiple GPUs, with accurate memory reporting via tools like `nvidia-smi`.
   - **Supported Models**: Includes `gemma3`, `llama4`, `qwen3`, `mistral-small3.2`, and more.

2. **Multimodal Engine (May 15, 2025)**
   - **Vision Support**: First-class support for vision models, including `llama4:scout` (109B parameters), `gemma3`, `qwen2.5vl`, and `mistral-small3.1`.
   - **Multimodal Tasks**: Examples include identifying animals in multiple images, answering location-based questions from videos, and document scanning.

These updates highlight Ollama's focus on efficiency, performance, and expanded capabilities for both text and vision tasks.
```

**Modelli consigliati:**

Questi modelli hanno eccellenti capacità di utilizzo degli strumenti e sono in grado di avere interazioni multi-turn con l'utente e gli strumenti per raggiungere un risultato finale.

-   `qwen3`
    
-   `gpt-oss`
    

**Modelli cloud consigliati:**

-   `qwen3:480b-cloud`
    
-   `gpt-oss:120b-cloud`
    
-   `deepseek-v3.1-cloud`
    

Gli strumenti `web_search` e `web_fetch` possono restituire migliaia di token. Si consiglia di aumentare la lunghezza del contesto del modello a circa 32000 token per prestazioni ragionevoli. Gli agenti di ricerca funzionano meglio con la lunghezza del contesto completa.

I modelli cloud come `qwen3:480b-cloud` offrono prestazioni superiori per compiti di ricerca complessi grazie alla maggiore capacità di contesto.

## Recuperare i risultati delle pagine

Per recuperare singole pagine (ad esempio quando un utente fornisce un URL nel prompt), usa la nuova API web fetch.

### Libreria Python

```python
from ollama import web_fetch

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

**Risultato**

```python
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']
)
```

Codice di esempio Python è disponibile su [GitHub](https://github.com/ollama/ollama-python/blob/main/examples/web-search.py).

### Libreria JavaScript

```javascript
import { Ollama } from "ollama";

const client = new Ollama();
const fetchResult = await client.webFetch({ url: "https://ollama.com" });
console.log(JSON.stringify(fetchResult, null, 2));
```

**Risultato**

```json
{
  "title": "Ollama",
  "content": "[Cloud models](https://ollama.com/blog/cloud-models) are now available in Ollama...",
  "links": [
    "https://ollama.com/",
    "https://ollama.com/models",
    "https://github.com/ollama/ollama"
  ]
}
```

Codice di esempio JavaScript è disponibile su [GitHub](https://github.com/ollama/ollama-js/blob/main/examples/websearch/websearch-tools.ts).

### cURL

```bash
curl --request POST \
  --url https://ollama.com/api/web_fetch \
  --header "Authorization: Bearer $OLLAMA_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
      "url": "ollama.com"
}'
```

**Risultato**

```bash
{
  "title": "Ollama",
  "content": "[Cloud models](https://ollama.com/blog/cloud-models) are now available in Ollama...",
  "links": [
    "http://ollama.com/",
    "http://ollama.com/models",
    "https://github.com/ollama/ollama"
  ]
}
```

## Integrazioni

### MCP Server (Model Context Protocol Server)

Puoi abilitare la web search in qualsiasi client MCP attraverso il [server MCP Python](https://github.com/ollama/ollama-python/blob/main/examples/web-search-mcp.py).

### Cline

Per integrare con Cline, configura i server MCP nelle sue impostazioni.

-   Manage MCP Servers > Configure MCP Servers > Aggiungi la configurazione sottostante
    

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

![Configurazione Cline per web search](/blogai/backend/uploads/6a18c9e62b06f.webp)

Configurazione di Cline per la web search

### Codex

Aggiungi la seguente configurazione a `~/.codex/config.toml`

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

![Demo di Codex](/blogai/backend/uploads/6a18c9e97000e.webp)

Configurazione di Codex per la web search

### Goose

Puoi integrare con Ollama tramite le estensioni di Goose.

![Goose - Integrazione Ollama](/blogai/backend/uploads/6a18c9ec68f2c.webp)

Goose - Integrazione Ollama parte 1

![Goose - Integrazione Ollama](/blogai/backend/uploads/6a18c9eec8cf9.webp)

Goose - Integrazione Ollama parte 2

## Come iniziare

La web search è inclusa con un account Ollama gratuito, con limiti di velocità molto più elevati disponibili aggiornando il tuo abbonamento a [Ollama Cloud](https://ollama.com/cloud).

Per iniziare, [registrati per un account Ollama](https://ollama.com/signup)!

## Punti chiave

-   Nuova API ufficiale di web search e web fetch integrata direttamente nell’ecosistema Ollama.
-   Disponibile sia tramite REST API (cURL) che con le librerie ufficiali per Python e JavaScript.
-   Offre un piano gratuito generoso per uso individuale, con limiti estesi su Ollama Cloud.
-   Permette ai modelli linguistici (come Qwen 3 o gpt-oss) di effettuare ricerche sul web in tempo reale e ridurre le allucinazioni.
-   Integrazione nativa con Model Context Protocol (MCP) per l’uso immediato in client come Cline, Codex e Goose.

### Svolta fondamentale per l’AI locale — 4.7/5

L’introduzione della ricerca web ufficiale all’interno di Ollama colma uno dei principali divari con i modelli proprietari commerciali. L’integrazione pulita tramite tool-use, unita a strumenti come web\_fetch ed MCP, rende la creazione di agenti autonomi di ricerca estremamente accessibile, veloce e ben ottimizzata.

## FAQ

### L’API di web search di Ollama è gratuita?

Sì, Ollama include un piano gratuito generoso per uso personale. Limiti di velocità più elevati sono disponibili sottoscrivendo un abbonamento su Ollama Cloud.

### Quali modelli sono consigliati per creare agenti di ricerca?

I modelli con ottime capacità di utilizzo degli strumenti (tool use), come qwen3 e gpt-oss, sia in versione locale che cloud (es. qwen3:480b-cloud).

### Qual è la differenza tra web\_search e web\_fetch?

web\_search esegue una ricerca a partire da una query testuale restituendo un elenco di corrispondenze, mentre web\_fetch scarica direttamente il testo ed i link di una specifica pagina a partire dal suo URL.

### Come si integra la ricerca web in strumenti come Cline o Codex?

Si può configurare il server Python MCP (Model Context Protocol) fornito da Ollama aggiungendo le relative righe al file di configurazione del client.

## Fonti e riferimenti

1.  [Ollama Blog - Web Search Announcement](https://ollama.com/blog/web-search)
2.  [Ollama Python SDK Web Search Examples](https://github.com/ollama/ollama-python/blob/main/examples/web-search.py)
3.  [Ollama JS SDK Web Search Examples](https://github.com/ollama/ollama-js/blob/main/examples/websearch/websearch-tools.ts)

---

*Fonte: [https://ainsights.it/blog/api-web-search-ollama-llm](https://ainsights.it/blog/api-web-search-ollama-llm)*
