> ## 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.

# Google ADK

> Tracez avec Weave un agent créé à l’aide de l’Agent Development Kit (ADK) de Google.

export const AgentLensBanner = ({href}) => <Tip>
    <strong>This workflow is also available in CoreWeave Agent Lens.</strong> Agent Lens is the Forge experience built for tracing, monitoring, and analyzing AI agents, with automated insights into agent failures and user intents. It uses the same trace data as Weights & Biases Weave, so the traces you already send appear there with nothing to migrate.{' '}
    <a href={href || '/products/agent-lens'}>{href ? 'See how to do this in Agent Lens' : 'Learn about Agent Lens'}</a>.
  </Tip>;

<AgentLensBanner href="/fr/products/agent-lens/integrations/google-adk" />

L'Agent Development Kit (ADK) de Google est un framework flexible et indépendant du modèle, conçu pour créer et orchestrer des agents. Bien qu’optimisé pour Gemini, ADK prend en charge n’importe quel modèle et convient aussi bien aux tâches simples qu’aux flux de travail multi-agents complexes. Weave trace automatiquement les agents créés avec ADK, y compris chaque appel d’agent, chaque transfert vers un sous-agent, chaque appel de modèle et chaque appel d’outil. Les données capturées s’affichent dans la vue **Agents** de votre projet.

<h2 id="trace-google-adk-agents-with-weave">
  Tracer des agents Google ADK avec Weave
</h2>

<Tabs>
  <Tab title="Python">
    Le SDK Weave applique automatiquement un patch à [Google ADK for Python](https://google.github.io/adk-docs/) pour vous permettre de capturer les traces de vos agents ADK avec une configuration minimale. Ce guide explique comment initialiser Weave, puis exécuter un agent de recherche sur plusieurs tours de conversation conçu avec Google ADK, afin que Weave capture chaque appel d’agent, appel de modèle et appel d’outil tout au long de la session.

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

    * Un compte CoreWeave Forge et une [clé API](https://forge.coreweave.com/settings#apikeys) définie dans la variable d’environnement `WANDB_API_KEY`.
    * Une [clé API Google](https://aistudio.google.com/apikey) pour Gemini.
    * Python 3.10 ou version ultérieure.
  </Tab>

  <Tab title="TypeScript">
    Weave s’intègre à [Google ADK for Node.js](https://google.github.io/adk-docs/) (`@google/adk`) pour tracer automatiquement les exécutions de vos agents.

    <h3 id="prerequisites-2">
      Prérequis
    </h3>

    * Un compte CoreWeave Forge et une [clé API](https://forge.coreweave.com/settings#apikeys) définie dans la variable d’environnement `WANDB_API_KEY`.
    * Une [clé API Google](https://aistudio.google.com/apikey) définie dans la variable d’environnement `GEMINI_API_KEY` ou `GOOGLE_GENAI_API_KEY`.
    * Node.js 18 ou version ultérieure.
    * `@google/adk` version `1.0.0` ou ultérieure.
  </Tab>
</Tabs>

<h3 id="install-packages">
  Installer les paquets
</h3>

Installez les paquets suivants dans votre environnement de développement. Ils fournissent le SDK Weave, le framework Google ADK et le client HTTP utilisé par l’outil de l’exemple.

<CodeGroup>
  ```bash Python theme={"system"}
  pip install weave google-adk requests
  ```

  ```bash TypeScript theme={"system"}
  npm install weave @google/adk zod
  ```
</CodeGroup>

<h3 id="initialize-weave-in-your-code">
  Initialiser Weave dans votre code
</h3>

<Tabs>
  <Tab title="Python">
    Ajoutez `weave.init` au projet en indiquant les noms de votre équipe et de votre projet CoreWeave Forge, puis créez un agent comme vous le feriez habituellement. Le code suivant crée un agent `research_assistant` qui utilise `gemini-2.5-flash` et un outil `wikipedia_search`, puis lui soumet trois questions au sein d’une même session ADK pendant que Weave capture la trace.

    ```python lines highlight="8" theme={"system"}
    import asyncio
    import requests
    import weave
    from google.adk.agents import Agent
    from google.adk.runners import InMemoryRunner
    from google.genai import types

    weave.init("<your-team>/<your-project-name>")

    def wikipedia_search(query: str) -> dict:
        """Search Wikipedia for a topic and return its title and intro paragraph.

        Args:
            query: The topic to search for.

        Returns:
            A dictionary with the article title and intro extract.
        """
        r = requests.get(
            "https://en.wikipedia.org/w/api.php",
            params={
                "action": "query", "generator": "search", "gsrsearch": query, "gsrlimit": 1,
                "prop": "extracts", "exintro": True, "explaintext": True, "format": "json",
            },
            headers={"User-Agent": "weave-demo"},
        ).json()
        page = next(iter(r["query"]["pages"].values()))
        return {"title": page["title"], "extract": page["extract"]}

    agent = Agent(
        name="research_assistant",
        model="gemini-2.5-flash",
        instruction=(
            "You are a research assistant. Use the wikipedia_search tool to look up "
            "topics when needed, and cite the article titles you used."
        ),
        tools=[wikipedia_search],
    )

    async def main():
        runner = InMemoryRunner(agent=agent, app_name="research-app")
        session = await runner.session_service.create_session(
            app_name="research-app", user_id="user-1"
        )

        questions = [
            "Who founded Anthropic?",
            "What is Claude (the AI assistant)?",
            "Summarize what we discussed in one sentence.",
        ]

        for question in questions:
            print(f"USER: {question}")
            async for event in runner.run_async(
                user_id="user-1",
                session_id=session.id,
                new_message=types.Content(
                    role="user",
                    parts=[types.Part(text=question)],
                ),
            ):
                if event.is_final_response() and event.content:
                    print(f"AGENT: {event.content.parts[0].text}\n")

    asyncio.run(main())
    ```

    L’exemple exécute trois tours de conversation dans une même session ADK. Les deux premiers tours déclenchent des recherches sur Wikipédia, et le troisième s’appuie sur le contexte de la conversation précédente pour produire une synthèse sans appel d’outil.
  </Tab>

  <Tab title="TypeScript">
    Weave trace les runners `@google/adk` au moyen du `WeaveAdkPlugin`, que vous enregistrez directement dans le tableau `plugins` du runner. L’enregistrement explicite du plugin fonctionne de la même manière dans les projets ESM et CommonJS ; aucune configuration de hook du chargeur de modules n’est donc requise.

    Le code suivant crée un agent `research_assistant` doté d’un outil `wikipedia_search`, puis soumet trois questions au sein d’une même session ADK pendant que Weave capture la trace.

    ```typescript lines highlight="35" theme={"system"}
    import * as weave from "weave";
    import { FunctionTool, Gemini, InMemoryRunner, LlmAgent } from "@google/adk";
    import { WeaveAdkPlugin } from "weave";
    import { z } from "zod";

    const GEMINI_API_KEY = process.env.GEMINI_API_KEY

    const wikipediaSearchTool = new FunctionTool({
      name: "wikipedia_search",
      description: "Search Wikipedia for a topic and return its title and intro paragraph.",
      parameters: z.object({
        query: z.string().describe("The topic to search for"),
      }),
      execute: async ({ query }) => {
        const url = new URL("https://en.wikipedia.org/w/api.php");
        url.search = new URLSearchParams({
          action: "query",
          generator: "search",
          gsrsearch: query,
          gsrlimit: "1",
          prop: "extracts",
          exintro: "true",
          explaintext: "true",
          format: "json",
        }).toString();

        const response = await fetch(url, { headers: { "User-Agent": "weave-demo" } });
        const data = await response.json();
        const page = Object.values(data.query.pages)[0] as { title: string; extract: string };
        return { title: page.title, extract: page.extract };
      },
    });

    async function main() {
      await weave.init("<your-team>/<your-project-name>");

      const agent = new LlmAgent({
        name: "research_assistant",
        description: "Answers research questions using Wikipedia.",
        instruction:
          "You are a research assistant. Use the wikipedia_search tool to look up " +
          "topics when needed, and cite the article titles you used.",
        model: new Gemini({ model: "gemini-2.5-flash", apiKey: GEMINI_API_KEY }),
        tools: [wikipediaSearchTool],
      });

      const APP_NAME = "weave-adk-example";
      const USER_ID = "example-user";

      const runner = new InMemoryRunner({
        agent,
        appName: APP_NAME,
        plugins: [new WeaveAdkPlugin()],
      });
      const session = await runner.sessionService.createSession({
        appName: APP_NAME,
        userId: USER_ID,
      });

      const questions = [
        "Who founded Anthropic?",
        "What is Claude (the AI assistant)?",
        "Summarize what we discussed in one sentence.",
      ];

      for (const question of questions) {
        console.log(`USER: ${question}`);
        for await (const event of runner.runAsync({
          userId: USER_ID,
          sessionId: session.id,
          newMessage: {
            role: "user",
            parts: [{ text: question }],
          },
        })) {
          const text = event.content?.parts
            ?.map(part => part.text)
            .filter(Boolean)
            .join("");
          if (text) {
            console.log(`AGENT: ${text}\n`);
          }
        }
      }

      await weave.flushOTel();
    }

    main().catch(console.error);
    ```

    L’exemple exécute trois tours de conversation dans une même session ADK. Les deux premiers déclenchent des recherches sur Wikipédia, et le troisième s’appuie sur le contexte des échanges précédents pour produire une synthèse sans appel d’outil.
  </Tab>
</Tabs>

<h3 id="see-your-agent-traces-in-the-agents-view">
  Consulter les traces de votre agent dans la vue Agents
</h3>

Une fois le script exécuté, `weave.init()` affiche un lien vers votre projet. Ouvrez la vue **Agents** pour examiner :

* Une session regroupant les tours de conversation.
* Chaque tour de conversation, représenté par un span `invoke_agent` contenant des spans enfants imbriqués `chat` et `execute_tool`.
* L’entrée complète, le modèle, la sortie, l’utilisation des jetons et les résultats des outils à chaque étape.

Pour en savoir plus sur l’affichage des données Agents dans Weave, consultez [Afficher l’activité des agents](/fr/products/wandb/weave/guides/tracking/view-agent-activity).


## Related topics

- [Aperçu des intégrations](/fr/products/wandb/weave/guides/integrations.md)
