Documentación

Herramientas de OpenAI

El adaptador de OpenAI permite que los modelos GPT interactúen con Asset Core a través de la llamada a funciones, utilizando la misma superficie de herramientas que otros adaptadores.

Requisitos Previos

  • Daemons de Asset Core en ejecución
  • Acceso a la API de OpenAI
  • Python o Rust para integración

Paso 1 - Obtener definiciones de herramientas

El adaptador proporciona definiciones de herramientas compatibles con OpenAI:

use assetcore_adapters::openai::tools::OpenAiToolDefinition;

let tools = OpenAiToolDefinition::all();

En Python, formatearías estos como especificaciones de funciones para la API de OpenAI.

Paso 2 - Definir las herramientas para OpenAI

Format tools for the OpenAI Chat Completions API:

tools = [
    {
        "type": "function",
        "function": {
            "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"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "assetcore_write_health",
            "description": "Check Asset Core write daemon health",
            "parameters": {"type": "object", "properties": {}}
        }
    }
]

Paso 3 - Ejecutar llamadas a herramientas

Cuando GPT devuelve una llamada a la herramienta, ejecútala contra Asset Core:

import httpx
import json

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

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

    else:
        return json.dumps({"error": f"Unknown tool: {tool_name}"})

Paso 4 - Completar el ciclo de conversación

Integrarse con la API de OpenAI:

from openai import OpenAI

client = OpenAI()

messages = [
    {"role": "user", "content": "Create a container with ID 1001"}
]

response = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

# Check for tool calls
if response.choices[0].message.tool_calls:
    for tool_call in response.choices[0].message.tool_calls:
        result = await execute_tool(
            tool_call.function.name,
            json.loads(tool_call.function.arguments)
        )

        # Add tool result to messages
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": result
        })

    # Get final response
    final_response = client.chat.completions.create(
        model="gpt-4",
        messages=messages
    )

Paso 5 - Utilizar el ejecutor de Rust

Para aplicaciones de Rust, utiliza el ejecutor incorporado:

use assetcore_adapters::openai::executor::OpenAiToolExecutor;
use assetcore_adapters::http_client::DaemonClient;

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

let executor = OpenAiToolExecutor::new(client);

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

Solución de problemas

Argumentos de función inválidos

GPT puede generar argumentos que no coinciden con el esquema. Valide antes de la ejecución y devuelva mensajes de error claros.

Limitación de tasa

OpenAI tiene límites de tasa. Implemente retrocesos y reintentos para su uso en producción.

Orden de llamada de herramientas

GPT puede solicitar múltiples llamadas a herramientas en paralelo. Los compromisos de Asset Core son secuenciales; ejecútalos en orden.

Próximos pasos