Instrumentare le applicazioni ADK con OpenTelemetry

Anteprima

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini di servizio generali dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Questo documento descrive come instrumentare un agente AI creato con il framework Agent Development Kit (ADK). Questa strumentazione, che sfrutta OpenTelemetry, ti consente di raccogliere i prompt degli utenti, le risposte dell'agente e le scelte dell'agente.

Il framework ADK è instrumentato con OpenTelemetry, che acquisisce i dati di telemetria dai passaggi chiave dell'esecuzione dell'agente. Ciò fornisce un'osservabilità dell'applicazione preziosa e pronta all'uso. Tuttavia, questa osservabilità potrebbe non essere sufficiente per il caso d'uso della tua applicazione. Puoi aggiungere librerie di strumentazione aggiuntive utilizzando OpenTelemetry per acquisire la telemetria da altre parti della tua app o la tua strumentazione personalizzata per acquisire dati specifici dell'applicazione e ottenere un'osservabilità più granulare.

Ad esempio, nella tua applicazione potresti scrivere codice di strumentazione per:

• Monitorare il consumo di risorse degli strumenti richiamati dall'agente.
• Tieni traccia degli errori di convalida specifici dell'applicazione, delle violazioni delle regole aziendali o dei meccanismi di recupero degli errori personalizzati.
• Monitora i punteggi di qualità per le risposte degli agenti in base ai criteri specifici del tuo dominio.

Instrumenta l'applicazione di AI generativa per raccogliere dati di telemetria

Per instrumentare l'agente AI in modo da raccogliere dati di log, metriche e tracciamento, procedi nel seguente modo:

1. Installare i pacchetti OpenTelemetry
2. Configurare OpenTelemetry per raccogliere e inviare dati di telemetria
3. Scrivere un punto di ingresso personalizzato per inserire OpenTelemetry configurato

Il resto di questa sezione descrive i passaggi precedenti.

Installa i pacchetti OpenTelemetry

Aggiungi i seguenti pacchetti di strumentazione ed esportazione OpenTelemetry:

pip install 'opentelemetry-instrumentation-google-genai' \
  'opentelemetry-instrumentation-sqlite3' \
  'opentelemetry-exporter-gcp-logging' \
  'opentelemetry-exporter-gcp-monitoring' \
  'opentelemetry-exporter-otlp-proto-grpc' \
  'opentelemetry-instrumentation-vertexai>=2.0b0'

I dati di log e delle metriche vengono inviati al tuo progetto Google Cloud utilizzando l'API Cloud Logging o l'API Cloud Monitoring. Le librerie opentelemetry-exporter-gcp-logging e opentelemetry-exporter-gcp-monitoring richiamano gli endpoint in queste API.

I dati di Trace vengono inviati a Google Cloud utilizzando l'API Telemetry (OTLP), che supporta il formato OTLP. I dati ricevuti tramite questo endpoint vengono archiviati anche nel formato OTLP. La libreria opentelemetry-exporter-otlp-proto-grpc richiama l'endpoint API Telemetry (OTLP).

Configurare OpenTelemetry per raccogliere e inviare dati di telemetria

Nel codice di inizializzazione dell'agente ADK, aggiungi il codice per configurare OpenTelemetry in modo da acquisire e inviare la telemetria al tuo progetto Google Cloud :

Per visualizzare l'esempio completo, fai clic su Altro, quindi seleziona Visualizza su GitHub.

def setup_opentelemetry() -> None:
    credentials, project_id = google.auth.default()
    resource = Resource.create(
        attributes={
            SERVICE_NAME: "adk-sql-agent",
            # The project to send spans to
            "gcp.project_id": project_id,
        }
    )

    # Set up OTLP auth
    request = google.auth.transport.requests.Request()
    auth_metadata_plugin = AuthMetadataPlugin(credentials=credentials, request=request)
    channel_creds = grpc.composite_channel_credentials(
        grpc.ssl_channel_credentials(),
        grpc.metadata_call_credentials(auth_metadata_plugin),
    )

    # Set up OpenTelemetry Python SDK
    tracer_provider = TracerProvider(resource=resource)
    tracer_provider.add_span_processor(
        BatchSpanProcessor(
            OTLPSpanExporter(
                credentials=channel_creds,
                endpoint="https://telemetry.googleapis.com:443/v1/traces",
            )
        )
    )
    trace.set_tracer_provider(tracer_provider)

    logger_provider = LoggerProvider(resource=resource)
    logger_provider.add_log_record_processor(
        BatchLogRecordProcessor(CloudLoggingExporter())
    )
    logs.set_logger_provider(logger_provider)

    event_logger_provider = EventLoggerProvider(logger_provider)
    events.set_event_logger_provider(event_logger_provider)

    reader = PeriodicExportingMetricReader(CloudMonitoringMetricsExporter())
    meter_provider = MeterProvider(metric_readers=[reader], resource=resource)
    metrics.set_meter_provider(meter_provider)

    # Load instrumentors
    SQLite3Instrumentor().instrument()
    # ADK uses Vertex AI and Google Gen AI SDKs.
    VertexAIInstrumentor().instrument()
    GoogleGenAiSdkInstrumentor().instrument()

Scrivere un punto di ingresso personalizzato per utilizzare OpenTelemetry configurato

Per utilizzare OpenTelemetry per l'instrumentazione, crea un punto di ingresso personalizzato per l'applicazione ADK. Il punto di contatto personalizzato deve configurare OpenTelemetry prima di avviare l'agente ADK.

Nell'applicazione di esempio, il metodo main funge da punto di ingresso personalizzato che inizializza OpenTelemetry e poi avvia il server FastAPI che ti consente di interagire con l'agente.

Per visualizzare l'esempio completo, fai clic su Altro, quindi seleziona Visualizza su GitHub.

def main() -> None:
    # Make sure to set:
    # OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED=true
    # OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true
    # in order to full prompts and responses and logs messages.
    # For this sample, these can be set by loading the `opentelemetry.env` file.
    setup_opentelemetry()

    # Call the function to get the FastAPI app instance.
    # Ensure that the agent director name is the name of directory containing agent subdirectories,
    # where each subdirectory represents a single agent with __init__.py and agent.py files.
    # For this example this would be the current directory containing main.py.
    # Note: Calling this method attempts to set the global tracer provider, which has already been
    # set by the setup_opentelemetry() function.
    app = get_fast_api_app(
        agents_dir=AGENT_DIR,
        session_service_uri=SESSION_DB_URL,
        allow_origins=ALLOWED_ORIGINS,
        web=SERVE_WEB_INTERFACE,
    )

    # Lauch the web interface on port 8080.
    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))

Scarica ed esegui l'applicazione di esempio

Questo codice campione implementa un agente di AI generativa creato utilizzando l'ADK. L'agente è instrumentato con OpenTelemetry, configurato per inviare metriche, tracce e log al tuo progetto Google Cloud . La telemetria inviata al tuo progetto include prompt e risposte dell'AI generativa.

Persona dell'agente ADK

L'agente di AI generativa è definito come un esperto di SQL che ha accesso completo a un database SQLite temporaneo. L'agente è creato con Agent Development Kit e accede a un database utilizzando SQLDatabaseToolkit. Il database è inizialmente vuoto.

Prima di iniziare

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Enable the Vertex AI, Telemetry, Cloud Logging, Cloud Monitoring, and Cloud Trace APIs.

   Enable the APIs

3. Per ottenere le autorizzazioni necessarie per consentire alle applicazioni di esempio di scrivere dati di log, metriche e tracce, chiedi all'amministratore di concederti i seguenti ruoli IAM nel tuo progetto:

   • Cloud Telemetry Traces Writer (roles/telemetry.tracesWriter)
   • Logs Writer (roles/logging.logWriter)
   • Monitoring Metric Writer (roles/monitoring.metricWriter)
   • Utente Vertex AI (roles/aiplatform.user)

Avvia l'applicazione

Per avviare l'applicazione di esempio:

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Clona il repository:

   git clone https://github.com/GoogleCloudPlatform/opentelemetry-operations-python.git
   

3. Vai alla directory di esempio:

   cd opentelemetry-operations-python/samples/adk-sql-agent
   

4. Crea un ambiente virtuale ed esegui l'esempio:

   python -m venv venv/
   source venv/bin/activate
   pip install -r requirements.txt
   env $(cat opentelemetry.env | xargs) python main.py
   

   L'applicazione mostra un messaggio simile al seguente:

   Appplication startup complete
   Uvicorn running on http://0.0.0.0:8080
   

5. Per interagire con l'agente, apri un browser all'indirizzo elencato nel passaggio precedente.

6. Espandi Seleziona un agente e seleziona sql_agent dall'elenco degli agenti.

Interagisci con l'agente

Per interagire con l'agente, fagli una domanda o dai un comando. Ad esempio, potresti porre la domanda:

What can you do for me ?

Analogamente, poiché sql_agent ha la personalità di un esperto di SQL, potresti chiedergli di creare tabelle per le tue applicazioni e scrivere query per operare sulle tabelle create. L'agente può creare solo un database temporaneo supportato da un file .db creato sulla macchina che esegue l'applicazione.

Di seguito è illustrata un'interazione di esempio tra sql_agent e l'utente:

Create a table for me to store weather data and also insert sample data in
the table. At the end show all data in the table you created.



Le azioni eseguite dagli agenti di AI generativa non sono deterministiche, quindi potresti visualizzare una risposta diversa per lo stesso prompt.

Esci dall'applicazione

Per uscire dall'applicazione, inserisci Ctrl-C nella shell utilizzata per avviare l'applicazione.

Visualizza le tracce, le metriche e i log

Questa sezione descrive come visualizzare gli eventi di AI generativa.

Prima di iniziare

Per ottenere le autorizzazioni necessarie per visualizzare i dati di log, metriche e tracce, chiedi all'amministratore di concederti i seguenti ruoli IAM sul progetto:

• Visualizzatore log (roles/logging.viewer)
• Monitoring Viewer (roles/monitoring.viewer)
• Utente Cloud Trace (roles/cloudtrace.user)

Per ulteriori informazioni sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Visualizza telemetria

Per visualizzare gli eventi di AI generativa creati dall'applicazione, utilizza la pagina Esplora tracce:

1. Nella Google Cloud console, vai alla pagina Esplora tracce:

   Vai a Trace Explorer

   Puoi trovare questa pagina anche utilizzando la barra di ricerca.

2. Nella barra degli strumenti, seleziona Aggiungi filtro, seleziona Nome span e poi seleziona call_llm.

   Di seguito è illustrata la pagina Esplora tracce dopo aver filtrato i dati:

   

   Se non hai mai utilizzato Cloud Trace, Google Cloud Observability deve creare un database per archiviare i dati di traccia. La creazione del database può richiedere alcuni minuti e durante questo periodo non sono disponibili dati di traccia da visualizzare.

3. Per esplorare i dati di intervallo e di log, seleziona un intervallo nella tabella Intervalli.

   Viene visualizzata la pagina Dettagli. Questa pagina mostra la traccia associata e i relativi intervalli. La tabella nella pagina mostra informazioni dettagliate per l'intervallo selezionato. Queste informazioni includono:

   • La scheda GenAI mostra gli eventi per gli agenti di AI generativa. Per scoprire di più su questi eventi, consulta Visualizzare gli eventi di AI generativa.

     Lo screenshot seguente mostra una traccia in cui uno span ha il nome call_llm. Questo intervallo richiama il modello linguistico di grandi dimensioni (LLM) che alimenta questo agente. Per questo esempio, è Gemini. L'intervallo Gemini include eventi di AI generativa:

     

   • La scheda Log ed eventi elenca le voci di log e gli eventi associati allo span. Se vuoi visualizzare i dati di log in Esplora log, seleziona Visualizza log nella barra degli strumenti di questa scheda.

     I dati di log includono la risposta di sql_agent. Ad esempio, per l'esecuzione di esempio, il payload JSON include i seguenti contenuti:

     {
       "logName": "projects/my-project/logs/otel_python_inprocess_log_name_temp",
       "jsonPayload": {
         "content": {
           "role": "model",
           "parts": [
             {
               "executable_code": null,
               "inline_data": null,
               "thought": null,
               "video_metadata": null,
               "code_execution_result": null,
               "function_response": null,
               "thought_signature": null,
               "text": "Okay, I will create a table named `weather` with columns `id`, `city`, `temperature`, and `date`. Then I will insert some sample rows into the table and display all the data in the table.\n",
               "file_data": null,
               "function_call": null
             }
           ]
         }
       },
       ...
     }
     

L'esempio è strumentato per inviare i dati delle metriche al tuo progetto Google Cloud , ma non genera metriche.