Costruire Agenti in Casa Gratuitamente: Strumenti e Modelli Open Source

Puoi costruire un sistema multi-agente funzionante sul tuo laptop usando solo strumenti gratuiti e modelli open source. Nessuna carta di credito, nessun limite di rate API, nessun lock-in con il vendor. Il compromesso? Inferenza più lenta e capacità leggermente inferiore. Ma per imparare, sperimentare e automazioni su piccola scala, è più che sufficiente.

Alla fine di questa guida, avrai un agente di ricerca locale in esecuzione sul tuo hardware — ricerca web, lettura file e sintesi di informazioni — completamente gratis.

Il Caso per lo Sviluppo di Agenti Open Source

Realtà dei Costi

I prezzi dell’API Claude sono ragionevoli per carichi di lavoro in produzione, ma imparare e sperimentare si accumula rapidamente. L’inferenza locale elimina completamente questa preoccupazione — iterazioni infinite a costo marginale zero.

Privacy e Controllo dei Dati

Alcuni carichi di lavoro non possono andare alle API cloud. Dati dei pazienti, codice proprietario, logica di business sensibile — tutti beneficiano di rimanere sulla tua macchina. I modelli locali forniscono lo stesso comportamento intelligente senza che alcun dato lasci il tuo hardware.

Il Controllo di Realtà

I modelli open source con 7–13B parametri sono notevolmente indietro rispetto ai modelli frontier nel ragionamento complesso, generazione di codice e rispetto delle istruzioni. Per la produzione dove la precisione conta, le API commerciali restano la scelta migliore. Per imparare e fare prototipi, i modelli locali sono ottimi.

Scegliere il Tuo LLM Open Source

Le Famiglie LLM

• Llama (Meta): La famiglia più ampiamente supportata. Llama 3 è particolarmente capace.
• Mistral: Eccellente rapporto qualità/parametri. Mistral-7B supera le sue dimensioni.
• Phi (Microsoft): Modelli piccoli estremamente efficienti. Phi-3 Mini funziona senza GPU.
• Qwen (Alibaba): Prestazioni multilingue solide.

Dimensioni del Modello e Requisiti Hardware

Quantizzazione: Perché È Importante

La quantizzazione comprime i pesi del modello per usare meno memoria. Un modello da 7B parametri in piena precisione richiede ~28GB di RAM. Lo stesso modello con quantizzazione a 4-bit ne richiede ~4GB, con minima perdita di qualità.

Punti di partenza per hardware:

• Laptop (8–16GB RAM): Phi-3 Mini o Mistral-7B a 4-bit
• Desktop con GPU media: Mistral-7B o Llama-3-8B con accelerazione GPU
• Desktop con GPU high-end: Mixtral-8x7B o Llama-3-70B a 4-bit

Configurazione dell’Inferenza Locale

Ollama: Il Punto di Ingresso Più Semplice

# Installa su macOS
brew install ollama

# Installa su Linux
curl -fsSL https://ollama.com/install.sh | sh

# Scarica Mistral-7B
ollama pull mistral

# Opzione più leggera per hardware lento
ollama pull phi3

# Avvia il server di inferenza
ollama serve

Verifica che funzioni:

curl http://localhost:11434/api/generate -d '{
  "model": "mistral",
  "prompt": "Cos'\''è un agente AI in una frase?",
  "stream": false
}'

LM Studio: Alternativa con Interfaccia Grafica

LM Studio è un’applicazione desktop che fornisce un’interfaccia grafica per scaricare ed eseguire modelli. Espone un endpoint API compatibile con OpenAI.

Framework per Agenti Open Source

Inizia con AutoGen o LangChain. AutoGen è più veloce per prototipare; LangChain dà più controllo sul loop dell’agente.

Costruire il Tuo Primo Agente: Assistente di Ricerca Locale

Configurazione dell’Ambiente

python3 -m venv agent-env
source agent-env/bin/activate
pip install langchain langchain-ollama langchain-community duckduckgo-search

L’Agente Completo

#!/usr/bin/env python3
"""
Agente di Ricerca Locale con Ollama + LangChain
Prerequisiti:
  - ollama serve (in esecuzione in background)
  - ollama pull mistral
  - pip install langchain langchain-ollama langchain-community duckduckgo-search
"""

import json
from langchain_core.tools import tool
from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama import ChatOllama
from langchain.agents import AgentExecutor, create_react_agent
from duckduckgo_search import DDGS


@tool
def search_web(query: str) -> str:
    """Cerca informazioni sul web usando DuckDuckGo."""
    try:
        with DDGS() as ddgs:
            results = list(ddgs.text(query, max_results=5))
        if not results:
            return "Nessun risultato trovato."
        return json.dumps(
            [{"title": r["title"], "snippet": r["body"], "url": r["href"]}
             for r in results],
            indent=2
        )
    except Exception as e:
        return f"Ricerca fallita: {e}"


@tool
def read_file(filepath: str) -> str:
    """Legge un file locale e restituisce il suo contenuto."""
    try:
        with open(filepath, "r") as f:
            return f.read()
    except FileNotFoundError:
        return f"File non trovato: {filepath}"


@tool
def calculate(expression: str) -> str:
    """Valuta in modo sicuro una semplice espressione aritmetica."""
    try:
        result = eval(expression, {"__builtins__": {}}, {})
        return str(result)
    except Exception as e:
        return f"Errore di calcolo: {e}"


llm = ChatOllama(
    model="mistral",
    base_url="http://localhost:11434",
    temperature=0.3,
)

prompt = ChatPromptTemplate.from_messages([
    ("system", """Sei un assistente di ricerca. Rispondi alle domande usando i tuoi strumenti.

Strumenti disponibili: {tool_names}
Descrizioni degli strumenti: {tools}

Segui esattamente questo formato:
Thought: Cosa devo scoprire?
Action: nome_strumento
Action Input: l'input per lo strumento
Observation: risultato dello strumento
... (ripeti secondo necessità)
Thought: Ora ho abbastanza informazioni.
Final Answer: la tua risposta completa"""),
    ("user", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

tools = [search_web, read_file, calculate]
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=8,
    handle_parsing_errors=True,
)

if __name__ == "__main__":
    result = agent_executor.invoke({
        "input": "Quali sono i tre LLM open source più popolari adesso? Dai i nomi e una caratteristica chiave di ciascuno."
    })
    print(f"\nRISPOSTA FINALE:\n{result['output']}")

Esecuzione

# Terminale 1: Avvia Ollama
ollama serve

# Terminale 2: Esegui l'agente
python research_agent.py

Espandere le Capacità: Strumenti Senza API

Accesso al Database Locale

import sqlite3

@tool
def query_database(sql: str) -> str:
    """Esegue una query SQL in sola lettura sul database locale."""
    try:
        conn = sqlite3.connect("data.db")
        cursor = conn.cursor()
        cursor.execute(sql)
        rows = cursor.fetchall()
        columns = [desc[0] for desc in cursor.description]
        conn.close()
        return json.dumps([dict(zip(columns, row)) for row in rows], indent=2)
    except Exception as e:
        return f"Errore database: {e}"

Ricerca Locale di Documenti con Embedding

pip install sentence-transformers chromadb

from sentence_transformers import SentenceTransformer
import chromadb

model = SentenceTransformer("all-MiniLM-L6-v2")
client = chromadb.Client()
collection = client.create_collection("docs")

@tool
def search_docs(query: str) -> str:
    """Cerca documenti locali per similarità semantica."""
    results = collection.query(
        query_embeddings=[model.encode(query).tolist()],
        n_results=3
    )
    return json.dumps(results["documents"][0], indent=2)

Limitazioni del Mondo Reale e Soluzioni

Latenza

Aspettati 2–30 secondi per ogni passo di inferenza. Strategie:

• Progetta agenti con meno passaggi; più semplice è più veloce
• Raggruppa le chiamate agli strumenti dove possibile

Lacune di Precisione

Strategie di mitigazione:

• Prompt più brevi ed espliciti — Specifica esattamente il formato atteso
• Suddividi i compiti complessi in passaggi
• Valida gli output degli strumenti prima di restituirli all’agente
• Usa temperatura 0,1–0,3 per l’uso degli strumenti

Deployment: Dal Laptop a Sempre Attivo

Docker

FROM python:3.12-slim
RUN pip install langchain langchain-ollama langchain-community duckduckgo-search
COPY research_agent.py .
ENV OLLAMA_HOST=host.docker.internal:11434
CMD ["python3", "research_agent.py"]

Servizio Systemd (Linux)

sudo systemctl enable ollama
sudo systemctl start ollama

Approfondire: Sistemi Multi-Agente in Casa

def run_pipeline(question: str) -> str:
    research_result = researcher.invoke({"input": question})
    final_output = writer.invoke({
        "input": f"Basandoti su questa ricerca, scrivi un riassunto chiaro:\n{research_result['output']}"
    })
    return final_output["output"]

Lo sviluppo di agenti open source è pratico oggi. Il percorso è: Ollama per l’inferenza, LangChain o AutoGen per il loop dell’agente, DuckDuckGo per la ricerca, e il filesystem della tua macchina per tutto il resto.

Inizia in modo semplice — con l’agente di ricerca sopra. Fallo funzionare. Poi aggiungi un secondo strumento. Poi un secondo agente.

Articoli Correlati

• Introduzione allo Sviluppo Agentico
• Pattern di Utilizzo degli Strumenti: Interfacce Agente-Strumento Affidabili
• Pattern Multi-Agente: Orchestratori, Worker e Pipeline
• Costruire il Tuo Primo Server MCP