> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-wbdocs-1882.mintlify.site/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 dans Weave les appels des agents et des outils [Agno](https://docs.agno.com/) à l’aide d’[OpenTelemetry (OTEL)](https://opentelemetry.io/). Agno est un framework Python permettant de créer des systèmes multi-agents avec mémoire, connaissances et raisonnement partagés. Il est conçu pour être léger, agnostique vis-à-vis des modèles et très performant, avec la prise en charge de capacités multimodales, notamment le traitement de texte, d’images, d’audio et de vidéo.

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

<Tip>
  Pour plus d’informations sur le tracing OTEL dans Weave, voir [Envoyer des traces OTEL à Weave](../tracking/otel).
</Tip>

<div id="prerequisites">
  ## Prérequis
</div>

1. Installez les dépendances requises :

   ```bash theme={null}
   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èle) dans une variable d’environnement :

   ```bash theme={null}
   export OPENAI_API_KEY=your_api_key_here
   ```

3. [Configurer le Tracing OTEL dans Weave](#configure-otel-tracing-in-weave).

<div id="configure-otel-tracing-in-weave">
  ### Configurer le Tracing OTEL dans Weave
</div>

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

<note>
  Nous vous recommandons de stocker les variables d’environnement sensibles, comme votre clé API et les informations sur votre projet, dans un fichier d’environnement (par exemple `.env`), puis de les charger avec `os.environ`. Cela permet de sécuriser vos identifiants et de les garder hors de votre code.
</note>

<div id="required-configuration">
  #### Configuration requise
</div>

* **Endpoint:** `https://trace.wandb.ai/otel/v1/traces`
* **En-têtes :**
  * `Authorization` : authentification Basic avec votre clé API W\&B
  * `project_id` : le nom de votre entité/projet W\&B (par ex. : `myteam/myproject`)

<div id="send-otel-traces-from-agno-to-weave">
  ## Envoyer des traces OTEL d’Agno vers Weave
</div>

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

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

```python lines theme={null}
# 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"
# Nom de votre entité/projet W&B, par ex. "myteam/myproject"
PROJECT_ID = os.environ.get("WANDB_PROJECT_ID")  
# Créez une clé API W&B sur https://wandb.ai/settings
WANDB_API_KEY = os.environ.get("WANDB_API_KEY")  

OTEL_EXPORTER_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'exportateur de spans OTLP avec l'endpoint et les en-têtes
exporter = OTLPSpanExporter(
    endpoint=OTEL_EXPORTER_OTLP_ENDPOINT,
    headers=OTEL_EXPORTER_OTLP_HEADERS,
)

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

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

<div id="trace-agno-agents-with-otel">
  ## Tracez les agents Agno avec OTEL
</div>

Après avoir configuré le fournisseur de traceurs, vous pouvez créer et exécuter des agents Agno avec le Tracing automatique. L’exemple suivant montre comment créer un agent simple avec des outils :

```python lines theme={null}
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éé ci-dessus
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 - cela sera automatiquement tracé
finance_agent.print_response(
    "What is the current stock price of Apple and what are the latest analyst recommendations?",
    stream=True
)
```

Toutes les opérations de l’agent font automatiquement l’objet d’un traçage et sont envoyées à Weave, ce qui vous permet de visualiser le flux d’exécution, les appels au modèle, les étapes de raisonnement et les appels aux outils.

<Frame>
  <img src="https://mintcdn.com/wb-21fd5541-wbdocs-1882/kTNBEU9hU1PbozeW/weave/guides/integrations/imgs/agno/agno_agent_trace.png?fit=max&auto=format&n=kTNBEU9hU1PbozeW&q=85&s=04023f0a71dd3b6ff1549a9ccc42b968" alt="Visualisation d’une trace d’un agent Agno" width="3016" height="1582" data-path="weave/guides/integrations/imgs/agno/agno_agent_trace.png" />
</Frame>

<div id="trace-agno-tools-with-otel">
  ## Tracez les outils Agno avec OTEL
</div>

Lorsque vous définissez et utilisez des outils avec Agno, les appels à ces outils sont également capturés dans la trace. L’intégration OTEL instrumente automatiquement à la fois le processus de raisonnement de l’agent et l’exécution de chaque outil, offrant une vue complète du comportement de votre agent.

Voici un exemple avec plusieurs outils :

```python lines theme={null}
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éé ci-dessus
from tracing import AgnoInstrumentor

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

# Créer un agent avec 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 - les appels d'outils seront tracés
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/wb-21fd5541-wbdocs-1882/kTNBEU9hU1PbozeW/weave/guides/integrations/imgs/agno/agno_tool_calls.png?fit=max&auto=format&n=kTNBEU9hU1PbozeW&q=85&s=dfb28c30deab0dc9415d956c00174b67" alt="Une visualisation de trace des appels d’outils Agno" width="3016" height="1582" data-path="weave/guides/integrations/imgs/agno/agno_tool_calls.png" />
</Frame>

<div id="trace-multi-agent-teams-with-otel">
  ## Tracez des équipes multi-agents avec OTEL
</div>

La puissante architecture multi-agents d'Agno vous permet de créer des équipes d'agents capables de collaborer et de partager du contexte. Ces interactions au sein des équipes sont elles aussi entièrement tracées :

```python lines theme={null}
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 tracin.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 - toutes les interactions des agents seront tracées
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 montrera comment différents agents se coordonnent dans Weave, en vous donnant de la visibilité sur la façon dont les tâches sont réparties et exécutées au sein de votre équipe d'agents.

<Frame>
  <img src="https://mintcdn.com/wb-21fd5541-wbdocs-1882/kTNBEU9hU1PbozeW/weave/guides/integrations/imgs/agno/agno_team_trace.png?fit=max&auto=format&n=kTNBEU9hU1PbozeW&q=85&s=8f606eb03567a9196abbfe9b4330d9b2" alt="Une visualisation de la trace de l'équipe multi-agent Agno" width="3016" height="1582" data-path="weave/guides/integrations/imgs/agno/agno_team_trace.png" />
</Frame>

<div id="work-with-reasoning-agents">
  ## Travaillez avec des agents capables de raisonner
</div>

Agno intègre des capacités de raisonnement qui aident les agents à analyser les problèmes étape par étape. Ces processus de raisonnement sont également capturés dans les traces :

```python lines theme={null}
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 tracin.py
from tracing import AgnoInstrumentor

# Démarrer 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
)
```

Les étapes du raisonnement seront visibles dans la trace, ce qui montre comment l’agent décompose des problèmes complexes et prend des décisions.

<Frame>
  <img src="https://mintcdn.com/wb-21fd5541-wbdocs-1882/kTNBEU9hU1PbozeW/weave/guides/integrations/imgs/agno/agno_reasoning_trace.png?fit=max&auto=format&n=kTNBEU9hU1PbozeW&q=85&s=3b30ee086fd6571e26d28716dcf7379c" alt="Une visualisation de la trace de l’agent de raisonnement Agno" width="3016" height="1582" data-path="weave/guides/integrations/imgs/agno/agno_reasoning_trace.png" />
</Frame>

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

Les agents Agno peuvent conserver une mémoire et accéder à des bases de connaissances. Ces opérations font également l’objet d’une trace :

```python lines theme={null}
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 tracin.py
from tracing import AgnoInstrumentor

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


# Créer un agent avec 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 souviendra 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/wb-21fd5541-wbdocs-1882/kTNBEU9hU1PbozeW/weave/guides/integrations/imgs/agno/agno_memory_use.png?fit=max&auto=format&n=kTNBEU9hU1PbozeW&q=85&s=bcd12b1c9b3ed886977f574dafbff2ff" alt="Une visualisation de la trace de l’utilisation de la mémoire d’Agno" width="3016" height="1582" data-path="weave/guides/integrations/imgs/agno/agno_memory_use.png" />
</Frame>

Les opérations sur la mémoire, notamment le stockage et la récupération de l’historique des conversations, seront visibles dans la trace.

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

* [Documentation Weave : envoyer des traces OTEL vers Weave](../tracking/otel)
* [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/)