> ## 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 un agent créé avec l’Agent Development Kit (ADK) de Google à l’aide d’Agent Lens.

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, aussi bien pour des tâches simples que pour des flux de travail multi-agents complexes. CoreWeave Agent Lens trace automatiquement les agents créés avec ADK, notamment chaque appel d’agent, chaque transfert vers un sous-agent, chaque appel de modèle et chaque appel d’outil. Agent Lens affiche les données capturées dans l’onglet **Conversations** de votre projet.

<Note>
  This integration uses the Weights & Biases Weave SDK (`weave`), because the CoreWeave Forge SDK doesn't support this framework yet. Traces you send with Weave appear in Agent Lens, because both products share the same trace data.
</Note>

<h2 id="trace-google-adk-agents-with-agent-lens">
  Tracer des agents Google ADK avec Agent Lens
</h2>

<Tabs>
  <Tab title="Python">
    Le SDK Weave patche automatiquement [Google ADK pour Python](https://google.github.io/adk-docs/), ce qui vous permet 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 créé avec Google ADK et fonctionnant sur plusieurs tours de conversation, afin qu’Agent Lens capture chaque appel d’agent, chaque appel de modèle et chaque 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">
    Le SDK Weave s’intègre à [Google ADK pour 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-agent-lens-in-your-code">
  Initialiser Agent Lens dans votre code
</h3>

<Tabs>
  <Tab title="Python">
    Ajoutez `weave.init` au projet en indiquant les noms de votre équipe et de votre projet Forge, puis créez un agent comme vous le feriez habituellement. Le code suivant crée un agent `research_assistant` qui utilise `gemini-3.6-flash` et un outil `wikipedia_search`, puis lui soumet trois questions au cours d’une même session ADK, pendant qu’Agent Lens 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]")

    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-3.6-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 seule 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.

    Chaque tour transmet le même `session_id`. ADK définit `gen_ai.conversation.id` à partir de cette session, si bien qu’Agent Lens affiche les trois tours comme une seule conversation dans l’onglet **Conversations**. Si vous créez plutôt une session par tour, chaque tour apparaît comme une conversation distincte.
  </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 nécessaire.

    Le code suivant crée un agent `research_assistant` doté d’un outil `wikipedia_search`, puis lui soumet trois questions au sein d’une même session ADK, pendant qu’Agent Lens 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]");

      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-3.6-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 seule session ADK. Les deux premiers tours 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.

    Chaque tour transmet le même `sessionId`. ADK définit `gen_ai.conversation.id` à partir de cette session, si bien qu’Agent Lens affiche les trois tours comme une seule conversation dans l’onglet **Conversations**. Si vous créez à la place une session par tour, chaque tour apparaît comme une conversation distincte.
  </Tab>
</Tabs>

### View your traces in Agent Lens

After the script runs, `weave.init()` prints a link to your project in Weave. The same traces appear in Agent Lens, because both products share the same trace data. To view them in Agent Lens:

1. Navigate to [CoreWeave Forge](https://forge.coreweave.com) and select **Agent Lens** from the product menu.
2. Select your project.
3. In the Agent Lens side menu, select **Conversations**, and then select your conversation.

Each turn renders as an `invoke_agent` span with nested `chat` and `execute_tool` spans. Each span shows its input, model, output, token usage, and tool results.

For more information, see [View agent activity](/products/agent-lens/conversations/view-activity).