Agents IA Python : quel framework choisir en 2026 ?
smolagents vs Pydantic AI vs LangGraph

# Base (CodeAgent + ToolCallingAgent + outils natifs)
pip install smolagents

# + LiteLLM (Ollama, Anthropic, OpenAI, 100+ providers)
pip install 'smolagents[litellm]'

# + DuckDuckGoSearch + Whisper transcriber (outils courants)
pip install 'smolagents[toolkit]'

# + Interface Gradio
pip install 'smolagents[gradio]'

# + Sandbox E2B cloud (exécution sécurisée)
pip install 'smolagents[e2b]'

# + Inférence locale via Transformers
pip install 'smolagents[transformers]'

# Tout en une commande (dev)
pip install 'smolagents[litellm,toolkit,gradio]'

from smolagents import CodeAgent, InferenceClientModel, DuckDuckGoSearchTool

# Modèle via Hugging Face Inference API (Qwen3-Next par défaut)
model = InferenceClientModel()

# Agent avec outils natifs (web search + calcul + code Python)
agent = CodeAgent(
    tools=[DuckDuckGoSearchTool()],
    model=model,
    add_base_tools=True,  # Ajoute PythonInterpreterTool, FinalAnswerTool
    max_steps=10,
)

result = agent.run("Quelle est la racine carrée de la population de Paris en 2025 ?")
print(result)

# Step 1 : Le LLM génère ce code
results = web_search("population Paris 2025")
print(results)

# Observation : "Paris compte environ 2,1 millions d'habitants en 2025"

# Step 2 : Le LLM génère ce code (réutilise les variables du step 1)
import math
population = 2_100_000
racine = math.sqrt(population)
final_answer(f"La racine carrée de {population:,} est {racine:.1f}")

agent = CodeAgent(
    tools=[...],
    model=model,
    additional_authorized_imports=["pandas", "matplotlib", "numpy"],
    # ^ Imports autorisés en plus de la liste blanche par défaut
    use_structured_outputs_internally=True,
    # ^ LLM génère {"thoughts": "...", "code": "..."} → 2-7 pts de gain
    planning_interval=3,
    # ^ Replanning tous les 3 steps : le LLM met à jour sa stratégie
    max_steps=15,
    executor_type="local",  # ou "e2b", "docker", "modal", "wasm"
    stream_outputs=True,    # Affiche les prints en temps réel
)

from smolagents import ToolCallingAgent, InferenceClientModel

agent = ToolCallingAgent(
    tools=[search_tool, calculator_tool],
    model=model,
    max_tool_threads=4,  # Appels parallèles via ThreadPoolExecutor
)

result = agent.run("Compare les prix de l'or et de l'argent aujourd'hui")
# → Les deux recherches sont lancées en parallèle

from smolagents import tool

@tool
def get_stock_price(ticker: str, currency: str = "EUR") -> float:
    """
    Retourne le prix actuel d'une action boursière.

    Args:
        ticker: Le symbole boursier (ex: AAPL, NVDA, MSFT).
        currency: La devise de retour (EUR, USD, GBP).
    """
    # type hints + docstring Args: obligatoires
    return fetch_price_api(ticker, currency)

# Vérification de la définition générée
print(get_stock_price.inputs)
# {'ticker': {'type': 'string', 'description': 'Le symbole boursier (ex: AAPL, NVDA, MSFT).'},
#  'currency': {'type': 'string', 'description': 'La devise de retour (EUR, USD, GBP).'}}

from smolagents import Tool

class EmbeddingSearchTool(Tool):
    name = "embedding_search"
    description = "Recherche sémantique dans la base de connaissances."
    inputs = {
        "query": {"type": "string", "description": "La requête de recherche."},
        "k": {"type": "integer", "description": "Nombre de résultats à retourner."}
    }
    output_type = "string"

    def setup(self):
        # Appelé au premier usage — lazy init des ressources lourdes
        self.index = load_vector_index("knowledge_base.faiss")
        self.embedder = load_embedder()

    def forward(self, query: str, k: int = 3) -> str:
        vec = self.embedder.encode(query)
        results = self.index.search(vec, k)
        return "\n".join(results)

from smolagents import ToolCollection
from mcp import StdioServerParameters

# Charger des outils depuis Hugging Face Hub
coll = ToolCollection.from_hub("huggingface-tools/diffusion-tools-6")
agent = CodeAgent(tools=[*coll.tools], model=model)

# Charger des outils depuis un serveur MCP (stdio)
server = StdioServerParameters(command="uvx", args=["pubmedmcp@0.1.3"])
with ToolCollection.from_mcp(server, trust_remote_code=True) as tools:
    agent = CodeAgent(tools=[*tools.tools], model=model)
    result = agent.run("Résume les 3 dernières publications sur les vaccins ARNm")

# Depuis un serveur MCP HTTP Streamable (production)
with ToolCollection.from_mcp({"url": "http://mcp-service:8000/mcp", "transport": "streamable-http"}) as tools:
    agent = CodeAgent(tools=[*tools.tools], model=model)

from smolagents import CodeAgent, LiteLLMModel, DuckDuckGoSearchTool
from smolagents.tools import PythonInterpreterTool

model = LiteLLMModel(
    model_id="ollama_chat/qwen3:14b",
    api_base="http://localhost:11434",
    # api_key non requis pour Ollama local
    num_ctx=8192,   # CRITIQUE — défaut Ollama = 2048, insuffisant pour les agents
)

agent = CodeAgent(
    tools=[DuckDuckGoSearchTool(), PythonInterpreterTool()],
    model=model,
    additional_authorized_imports=["pandas", "numpy", "matplotlib"],
    max_steps=8,
)

result = agent.run(
    "Télécharge les données EUR/USD des 30 derniers jours et calcule la volatilité"
)
print(result)

# E2B cloud sandbox — une ligne de changement
with CodeAgent(model=model, tools=tools, executor_type="e2b") as agent:
    agent.run("Analyse ce CSV et génère un graphique")
# Le code s'exécute dans une VM isolée, pas sur le serveur local

# Docker local (nécessite Docker installé)
agent = CodeAgent(model=model, tools=tools, executor_type="docker")

# Modal cloud (scale-to-zero automatique)
agent = CodeAgent(model=model, tools=tools, executor_type="modal")

# WebAssembly via Pyodide (zéro installation cloud, via Deno)
agent = CodeAgent(model=model, tools=tools, executor_type="wasm")

from smolagents import CodeAgent, ToolCallingAgent, InferenceClientModel, WebSearchTool

model = InferenceClientModel()

# Agent spécialisé (ToolCallingAgent pour les recherches JSON-structurées)
web_agent = ToolCallingAgent(
    tools=[WebSearchTool()],
    model=model,
    name="web_search_agent",       # Requis
    description="Effectue des recherches web. Passe la requête complète en argument.",
    max_steps=5,
)

# Agent spécialisé analyse données
data_agent = CodeAgent(
    tools=[],
    model=model,
    name="data_analyst",
    description="Analyse des données, calcule des statistiques, génère des graphiques.",
    additional_authorized_imports=["pandas", "matplotlib", "scipy"],
)

# Agent manager — voit web_agent et data_agent comme des fonctions Python
manager = CodeAgent(
    tools=[],
    model=model,
    managed_agents=[web_agent, data_agent],
    planning_interval=2,  # Replanning tous les 2 steps
)

manager.run("Collecte les prix des actions NVDA sur 30 jours et analyse leur volatilité")

def web_search_agent(task: str, additional_args: dict[str, Any]) -> str:
    """Effectue des recherches web. Passe la requête complète en argument.

    Args:
        task: Description détaillée de la tâche.
        additional_args: Variables supplémentaires (images, DataFrames...).
    """

# Après un run, inspecter la mémoire
result = agent.run("Analyse ce fichier CSV", reset=False)

for step in agent.memory.steps:
    if hasattr(step, 'code_action'):
        print(f"Step {step.step_number} — Code généré :")
        print(step.code_action)
        print(f"Observation : {step.observations}")
        print(f"Tokens : {step.token_usage}")

# Récupérer tout le code généré en un seul script
full_script = agent.memory.return_full_code()

# Rejouer la session en mode debug
agent.memory.replay(agent.logger, detailed=True)

# Continuer une conversation (reset=False conserve l'historique)
result2 = agent.run("Maintenant génère un graphique de ce résultat", reset=False)

from smolagents import CodeAgent, InferenceClientModel, GradioUI

agent = CodeAgent(
    tools=[DuckDuckGoSearchTool()],
    model=InferenceClientModel(),
    add_base_tools=True,
)

# Interface chat complète avec upload de fichiers
GradioUI(
    agent,
    file_upload_folder="uploads",   # Dossier pour les fichiers uploadés
    reset_agent_memory=False,        # Conserve l'historique entre messages
).launch(share=True)  # share=True → URL publique temporaire

# Publier sur Hugging Face Hub comme Space
agent.push_to_hub("user/mon-agent-ia")
agent2 = CodeAgent.from_hub("user/mon-agent-ia", trust_remote_code=True)

from smolagents import CodeAgent, LiteLLMModel, tool
import os

model = LiteLLMModel(
    model_id="ollama_chat/qwen3:14b",
    api_base="http://localhost:11434",
    num_ctx=16384,
)

@tool
def read_csv_summary(filepath: str) -> str:
    """
    Lit un fichier CSV et retourne un résumé de ses colonnes et premières lignes.

    Args:
        filepath: Chemin absolu vers le fichier CSV à analyser.
    """
    import pandas as pd
    df = pd.read_csv(filepath)
    return f"Shape: {df.shape}\nColumns: {list(df.columns)}\nHead:\n{df.head(3).to_string()}\nDtypes:\n{df.dtypes.to_string()}"

agent = CodeAgent(
    tools=[read_csv_summary],
    model=model,
    additional_authorized_imports=["pandas", "numpy", "scipy"],
    max_steps=6,
)

result = agent.run(
    """Analyse le fichier /data/ventes_2025.csv :
    1. Calcule les statistiques descriptives des colonnes numériques
    2. Détecte les valeurs aberrantes (IQR method)
    3. Identifie les 3 produits avec la plus forte variance de ventes
    4. Rédige une conclusion en 3 points"""
)
print(result)
# L'agent génère et exécute du code pandas/numpy à chaque étape
# Les variables (df, stats, outliers...) persistent entre les steps