Documentació

OpenAI Eines

L’adaptador OpenAI permet als models GPT interactuar amb Asset Core mitjançant la invocació de funcions, utilitzant la mateixa superfície d’eina que altres adaptadors.

Requisits previs

  • Daemons d’Asset Core en execució
  • Accés a l’API d’OpenAI
  • Python o Rust per a la integració

Pas 1 - Obtenir definicions d’eines

L’adaptador proporciona definicions d’eines compatibles amb OpenAI:

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

let tools = OpenAiToolDefinition::all();

En Python, formataríeu aquests com a especificacions de funció per a l’API d’OpenAI.

Pas 2 - Definir les eines per OpenAI

Format d’eines per a l’API de Completions de Chat d’OpenAI:

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": {}}
        }
    }
]

Pas 3 - Executar trucades d’eines

Quan GPT retorna una crida d’eina, executa-la 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}"})

Pas 4 - Completar el cicle de conversa

Integrar-se amb l’API d’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
    )

Pas 5 - Utilitzeu l’executor Rust

Per a les aplicacions Rust, utilitzeu l’executor integrat:

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?;

Resolució de problemes

Arguments de funció no vàlids

GPT pot generar arguments que no coincideixen amb l’esquema. Valideu abans de l’execució i torneu missatges d’error clars.

Limitació de taxa

OpenAI té límits de taxa. Implementa retrocessos i reintents per a l’ús en producció.

Ordre de crida d’eines

GPT pot sol·licitar múltiples crides d’eines en paral·lel. Els compromisos d’Asset Core són seqüencials; executa’ls en ordre.

Properes passes