> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Agno

> Tracez les systèmes multi-agents Agno avec Weave à l’aide d’OpenTelemetry pour capturer les interactions entre agents, les appels d’outils et les flux de travail multimodaux.

Vous pouvez tracer les appels d’agents et d’outils [Agno](https://docs.agno.com/) dans Weave à l’aide d’[OpenTelemetry (OTEL)](https://opentelemetry.io/). Agno est un framework Python conçu pour créer des systèmes multi-agents qui partagent mémoire, connaissances et raisonnement. Léger et indépendant du modèle, il prend en charge des fonctionnalités multimodales, notamment le traitement de texte, d’images, d’audio et de vidéo.

Ce guide explique comment tracer les appels d’agents et d’outils Agno avec OTEL, puis visualiser ces traces dans Weave. Vous apprendrez à installer les dépendances requises, à configurer un traceur OTEL pour envoyer des données vers Weave et à instrumenter vos agents et outils Agno.

<Tip>
  Pour plus d’informations sur le traçage OTEL dans Weave, consultez [Envoyer des traces OTEL à Weave](/fr/products/wandb/weave/guides/tracking/otel).
</Tip>

<h2 id="prerequisites">
  Prérequis
</h2>

1. Installez les dépendances requises :

   ```bash theme={"system"}
   pip install agno openinference-instrumentation-agno opentelemetry-sdk opentelemetry-exporter-otlp-proto-http
   ```

2. Définissez votre clé API OpenAI (ou celle d’un autre fournisseur de modèles) comme variable d’environnement :

   ```bash theme={"system"}
   export OPENAI_API_KEY=your_api_key_here
   ```

3. [Configurez le traçage OTEL dans Weave](#configure-otel-tracing-in-weave).

<h3 id="configure-otel-tracing-in-weave">
  Configurer le traçage OTEL dans Weave
</h3>

Pour envoyer des traces d’Agno vers Weave, configurez OTEL avec un `TracerProvider` et un `OTLPSpanExporter`. Configurez l’exportateur avec le [point de terminaison et les en-têtes HTTP appropriés pour l’authentification et l’identification du projet](#required-configuration).

<Note>
  Stockez les variables d’environnement sensibles, comme votre clé API et les informations de votre projet, dans un fichier d’environnement (par exemple, `.env`), puis chargez-les avec `os.environ`. Vos identifiants d’authentification restent ainsi protégés et hors de votre base de code.
</Note>

<h4 id="required-configuration">
  Configuration requise
</h4>

Configurez l’exportateur OTLP avec le point de terminaison et les en-têtes suivants :

* **Point de terminaison :** `https://trace.wandb.ai/otel/v1/traces`
* **En-têtes :**
  * `Authorization` : authentification de base (Basic auth) avec votre clé API W\&B.
  * `project_id` : le nom de votre entity/projet W\&B (par exemple, `myteam/myproject`).

<h2 id="send-otel-traces-from-agno-to-weave">
  Envoyer des traces OTEL depuis Agno vers Weave
</h2>

Une fois les [prérequis](#prerequisites) remplis, vous pouvez envoyer des traces OTEL depuis Agno vers Weave. L’extrait de code suivant montre comment configurer un exportateur de spans OTLP et un fournisseur de traceurs pour envoyer des traces OTEL depuis une application Agno vers Weave.

<Warning>
  Pour que Weave trace correctement Agno, définissez le fournisseur de traceurs global *avant* d’utiliser des composants Agno dans votre code.
</Warning>

```python lines theme={"system"}
# tracing.py

import base64
import os
from openinference.instrumentation.agno import AgnoInstrumentor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk import trace as trace_sdk
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry import trace

# Charger les valeurs sensibles depuis les variables d'environnement
WANDB_BASE_URL = "https://trace.wandb.ai"
# Votre entity/nom de projet W&B, par exemple « myteam/myproject »
PROJECT_ID = os.environ.get("WANDB_PROJECT_ID")
# Créez une clé API W&B sur https://forge.coreweave.com/settings
WANDB_API_KEY = os.environ.get("WANDB_API_KEY")

WEAVE_OTLP_ENDPOINT = f"{WANDB_BASE_URL}/otel/v1/traces"
AUTH = base64.b64encode(f"api:{WANDB_API_KEY}".encode()).decode()

OTEL_EXPORTER_OTLP_HEADERS = {
    "Authorization": f"Basic {AUTH}",
    "project_id": PROJECT_ID,
}

# Créer l'exporteur de spans OTLP avec le point de terminaison et les en-têtes
exporter = OTLPSpanExporter(
    endpoint=WEAVE_OTLP_ENDPOINT,
    headers=OTEL_EXPORTER_OTLP_HEADERS,
)

# Créer un fournisseur de traceurs et y ajouter l'exporteur
tracer_provider = trace_sdk.TracerProvider()
tracer_provider.add_span_processor(SimpleSpanProcessor(exporter))

# Définir le fournisseur de traceurs global AVANT d'importer ou d'utiliser Agno
trace.set_tracer_provider(tracer_provider)
```

<h2 id="trace-agno-agents-with-otel">
  Tracer des agents Agno avec OTEL
</h2>

Une fois le fournisseur de traceurs configuré, vous pouvez créer et exécuter des agents Agno avec traçage automatique. Instrumentez Agno avant de créer vos agents afin que Weave capture toute l’activité ultérieure des agents. L’exemple suivant montre comment créer un agent doté d’outils :

```python lines theme={"system"}
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.yfinance import YFinanceTools

from dotenv import load_dotenv
load_dotenv()

# Charger AgnoInstrumentor depuis le fichier créé précédemment
from tracing import AgnoInstrumentor

# Démarrer l’instrumentation d’Agno
AgnoInstrumentor().instrument()

# Créer un agent financier
finance_agent = Agent(
    name="Finance Agent",
    model=OpenAIChat(id="gpt-4o-mini"),
    tools=[
        YFinanceTools(
            stock_price=True,
            analyst_recommendations=True,
            company_info=True,
            company_news=True
        )
    ],
    instructions=["Use tables to display data"],
    show_tool_calls=True,
    markdown=True,
)

# Utiliser l’agent : Weave trace automatiquement cet appel
finance_agent.print_response(
    "What is the current stock price of Apple and what are the latest analyst recommendations?",
    stream=True
)
```

Weave trace automatiquement toutes les opérations des agents, ce qui vous permet de visualiser le flux d’exécution, les appels de modèle, les étapes de raisonnement et les invocations d’outils.

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/agno_agent_trace.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=81d92d088338e21c71024a234106af37" alt="Visualisation de la trace d’un agent Agno" width="2908" height="1582" data-path="products/wandb/weave/_media/agno_agent_trace.png" />
</Frame>

<h2 id="trace-agno-tools-with-otel">
  Tracer les outils Agno avec OTEL
</h2>

Lorsque vous définissez et utilisez des outils avec Agno, la trace capture également ces appels d’outils. L’intégration OTEL instrumente automatiquement le processus de raisonnement de l'agent ainsi que chaque exécution d’outil, ce qui fournit une vue complète du comportement de votre agent.

Voici un exemple avec plusieurs outils :

```python lines theme={"system"}
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.yfinance import YFinanceTools

from dotenv import load_dotenv
load_dotenv()

# Charger AgnoInstrumentor depuis le fichier créé précédemment
from tracing import AgnoInstrumentor

# Démarrer l’instrumentation d’Agno
AgnoInstrumentor().instrument()

# Créer un agent doté de plusieurs outils
research_agent = Agent(
    name="Research Agent",
    model=OpenAIChat(id="gpt-4o-mini"),
    tools=[
        DuckDuckGoTools(),
        YFinanceTools(stock_price=True, company_info=True),
    ],
    instructions=[
        "Search for current information and financial data",
        "Always include sources",
        "Use tables to display financial data"
    ],
    show_tool_calls=True,
    markdown=True,
)

# Utiliser l’agent : Weave trace les appels d’outils
research_agent.print_response(
    "Research Tesla's recent performance and news. Include stock price and any recent developments.",
    stream=True
)
```

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/agno_tool_calls.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=2a1b232500d5da96a24bafb7f3ce3fbc" alt="Visualisation de la trace des appels d’outils Agno" width="2908" height="1582" data-path="products/wandb/weave/_media/agno_tool_calls.png" />
</Frame>

<h2 id="trace-multi-agent-teams-with-otel">
  Tracer des équipes multi-agents avec OTEL
</h2>

L'architecture multi-agents d'Agno vous permet de créer des équipes d'agents qui collaborent et partagent un contexte. Weave trace également l'intégralité des interactions au sein de ces équipes :

```python lines theme={"system"}
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.yfinance import YFinanceTools

from dotenv import load_dotenv
load_dotenv()

# Charger AgnoInstrumentor depuis le fichier tracing.py
from tracing import AgnoInstrumentor

# Démarrer l’instrumentation d’Agno
AgnoInstrumentor().instrument()

# Créer des agents spécialisés
web_agent = Agent(
    name="Web Agent",
    role="Search the web for information",
    model=OpenAIChat(id="gpt-4o-mini"),
    tools=[DuckDuckGoTools()],
    instructions="Always include sources",
    show_tool_calls=True,
    markdown=True,
)

finance_agent = Agent(
    name="Finance Agent",
    role="Get financial data",
    model=OpenAIChat(id="gpt-4o-mini"),
    tools=[YFinanceTools(stock_price=True, analyst_recommendations=True)],
    instructions="Use tables to display data",
    show_tool_calls=True,
    markdown=True,
)

# Créer une équipe d’agents
agent_team = Agent(
    team=[web_agent, finance_agent],
    model=OpenAIChat(id="gpt-4o"),
    instructions=["Always include sources", "Use tables to display data"],
    show_tool_calls=True,
    markdown=True,
)

# Utiliser l’équipe : Weave trace toutes les interactions entre les agents
agent_team.print_response(
    "What's the current market sentiment around NVIDIA? Include both news analysis and financial metrics.",
    stream=True
)
```

Cette trace multi-agent illustre la coordination entre les différents agents dans Weave, ce qui vous permet de voir comment les tâches sont réparties et exécutées au sein de votre équipe d’agents.

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/agno_team_trace.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=322ada104235c30177d518bad18f65c3" alt="Une visualisation de la trace d’une équipe multi-agent Agno" width="2908" height="1582" data-path="products/wandb/weave/_media/agno_team_trace.png" />
</Frame>

<h2 id="work-with-reasoning-agents">
  Utiliser des agents de raisonnement
</h2>

Agno fournit des capacités de raisonnement intégrées qui aident les agents à traiter les problèmes étape par étape. Les traces capturent également ces processus de raisonnement :

```python lines theme={"system"}
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.reasoning import ReasoningTools
from agno.tools.yfinance import YFinanceTools

from dotenv import load_dotenv
load_dotenv()

# Charger AgnoInstrumentor depuis le fichier tracing.py
from tracing import AgnoInstrumentor

# Lancer l’instrumentation d’Agno
AgnoInstrumentor().instrument()

# Créer un agent de raisonnement
reasoning_agent = Agent(
    name="Reasoning Finance Agent",
    model=OpenAIChat(id="gpt-4o"),
    tools=[
        ReasoningTools(add_instructions=True),
        YFinanceTools(
            stock_price=True,
            analyst_recommendations=True,
            company_info=True,
            company_news=True
        ),
    ],
    instructions="Use tables to display data and show your reasoning process",
    show_tool_calls=True,
    markdown=True,
)

# Utiliser l’agent de raisonnement
reasoning_agent.print_response(
    "Should I invest in Apple stock right now? Analyze the current situation and provide a reasoned recommendation.",
    stream=True
)
```

La trace affiche les étapes de raisonnement, qui montrent comment l’agent décompose les problèmes complexes et prend ses décisions.

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/agno_reasoning_trace.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=66b624b1e556b992a91d16090c23d492" alt="Visualisation de la trace d’un agent de raisonnement Agno" width="2908" height="1582" data-path="products/wandb/weave/_media/agno_reasoning_trace.png" />
</Frame>

<h2 id="work-with-memory-and-knowledge">
  Utiliser la mémoire et les connaissances
</h2>

Les agents Agno peuvent conserver une mémoire et accéder à des bases de connaissances, ce qui leur permet de conserver le contexte d’une interaction à l’autre. Weave trace également ces opérations :

```python lines theme={"system"}
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.memory import AgentMemory
from agno.storage.sqlite import SqliteStorage

from dotenv import load_dotenv
load_dotenv()

# Charger AgnoInstrumentor depuis le fichier tracing.py
from tracing import AgnoInstrumentor

# Démarrer l’instrumentation d’Agno
AgnoInstrumentor().instrument()


# Créer un agent doté d’une mémoire
memory_agent = Agent(
    name="Memory Agent",
    model=OpenAIChat(id="gpt-4o-mini"),
    memory=AgentMemory(),
    storage=SqliteStorage(
        table_name="agent_sessions",
        db_file="agent_memory.db"
    ),
    instructions="Remember our conversation history",
    show_tool_calls=True,
    markdown=True,
)

# Première interaction
memory_agent.print_response("My name is John and I'm interested in AI investing strategies.")

# Deuxième interaction : l’agent se souvient du contexte précédent
memory_agent.print_response("What specific AI companies would you recommend for my portfolio?")
```

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/agno_memory_use.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=1c0479d9d446b6ebaa2c07e734bace39" alt="Visualisation de la trace de l’utilisation de la mémoire par Agno" width="2908" height="1582" data-path="products/wandb/weave/_media/agno_memory_use.png" />
</Frame>

Les opérations de mémoire, notamment l’enregistrement et la récupération de l’historique des conversations, apparaissent dans la trace.

<h2 id="learn-more">
  En savoir plus
</h2>

* [Documentation officielle d’Agno](https://docs.agno.com/)
* [Documentation officielle d’OTEL](https://opentelemetry.io/)
* [Dépôt GitHub d’Agno](https://github.com/agno-agi/agno)
* [Instrumentation OpenInference pour Agno](https://pypi.org/project/openinference-instrumentation-agno/)