Documentación

Géminis

El adaptador Gemini permite que los modelos Gemini de Google interactúen con Asset Core a través de declaraciones de funciones, reflejando la misma superficie de herramientas que otros adaptadores.

Requisitos Previos

  • Daemons de Asset Core en ejecución
  • Acceso a la API de Google AI (Gemini)
  • Python o Rust para integración

Paso 1 - Obtener declaraciones de función

El adaptador proporciona declaraciones de función compatibles con Gemini:

use assetcore_adapters::gemini::GeminiToolDefinition;

let tools = GeminiToolDefinition::all();

Estas declaraciones siguen el esquema de llamadas a funciones de Google.

Paso 2 - Definir funciones para Gemini

Formatos de herramientas para la API de Gemini:

from google.generativeai.types import FunctionDeclaration, Tool

commit_function = FunctionDeclaration(
    name="assetcore_commit",
    description="Submit a transaction to Asset Core",
    parameters={
        "type": "object",
        "properties": {
            "operations": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "op": {"type": "string"},
                        "args": {"type": "object"}
                    },
                    "required": ["op", "args"]
                },
                "description": "List of operations to execute"
            },
            "idempotency_key": {
                "type": "string",
                "description": "Optional deduplication key"
            }
        },
        "required": ["operations"]
    }
)

health_function = FunctionDeclaration(
    name="assetcore_write_health",
    description="Check Asset Core write daemon health",
    parameters={"type": "object", "properties": {}}
)

tools = Tool(function_declarations=[commit_function, health_function])

Paso 3 - Ejecutar llamadas a funciones

Cuando Gemini devuelve una llamada a función, ejecútala contra Asset Core:

import httpx
import json

async def execute_function(name: str, args: dict) -> dict:
    if name == "assetcore_commit":
        async with httpx.AsyncClient() as client:
            response = await client.post(
                "http://localhost:8080/v1/commit",
                json=args
            )
            return response.json()

    elif name == "assetcore_write_health":
        async with httpx.AsyncClient() as client:
            response = await client.get(
                "http://localhost:8080/v1/health"
            )
            return response.json()

    else:
        return {"error": f"Unknown function: {name}"}

Paso 4 - Completar el ciclo de conversación

Integrarse con la API de Gemini:

import google.generativeai as genai

genai.configure(api_key="your-api-key")
model = genai.GenerativeModel(
    "gemini-pro",
    tools=[tools]
)

chat = model.start_chat()

response = chat.send_message(
    "Create a container with ID 1001"
)

# Check for function calls
if response.candidates[0].content.parts[0].function_call:
    fc = response.candidates[0].content.parts[0].function_call

    # Execute the function
    result = await execute_function(fc.name, dict(fc.args))

    # Send the result back
    response = chat.send_message(
        genai.protos.Content(
            parts=[
                genai.protos.Part(
                    function_response=genai.protos.FunctionResponse(
                        name=fc.name,
                        response={"result": result}
                    )
                )
            ]
        )
    )

    print(response.text)

Paso 5 - Utilizar el ejecutor de Rust

Para aplicaciones de Rust:

use assetcore_adapters::gemini::GeminiToolExecutor;
use assetcore_adapters::http_client::DaemonClient;

let client = DaemonClient::new(
    "http://localhost:8080",
    "http://localhost:8081"
);

let executor = GeminiToolExecutor::new(client);

let result = executor.execute(
    "assetcore_commit",
    serde_json::json!({
        "operations": [
            {
                "op": "CreateContainer",
                "args": {
                    "container_id": 1001,
                    "kind": "Standard"
                }
            }
        ]
    })
).await?;

Solución de problemas

Función no reconocida

Asegúrese de que el nombre de la función coincida exactamente. Gemini es sensible a mayúsculas y minúsculas.

Argumentos inválidos

Gemini puede generar argumentos que no coinciden con el esquema. Agregue validación antes de la ejecución.

Llamadas a múltiples funciones

Gemini puede solicitar múltiples llamadas a funciones. Ejéctalas secuencialmente para Asset Core.

Próximos pasos