Servicio de IA

ObjectOS trata la IA como una capacidad de primera clase con tres capas conectables:

Las tres son opcionales, las tres son independientes del proveedor y las tres pueden reconfigurarse en tiempo de ejecución desde Console → Configuration sin necesidad de reiniciar.

Chat / generación

Impulsado por el Vercel AI SDK. Instala el o los proveedores que quieras como peer deps:

pnpm add @ai-sdk/openai          # OpenAI
pnpm add @ai-sdk/anthropic       # Claude
pnpm add @ai-sdk/google          # Gemini
pnpm add @ai-sdk/gateway         # AI gateway / OpenRouter / proxies

Luego registra el plugin del servicio de IA con un adaptador del Vercel-SDK:

import { AIServicePlugin, VercelLLMAdapter } from '@objectstack/service-ai';
import { openai } from '@ai-sdk/openai';

kernel.use(new AIServicePlugin({
  adapter: new VercelLLMAdapter({ model: openai('gpt-4o') }),
  models: [
    { id: 'fast',  provider: 'openai', model: 'gpt-4o-mini' },
    { id: 'smart', provider: 'openai', model: 'gpt-4o' },
  ],
  defaultModelId: 'fast',
}));

La lista models alimenta el registro de modelos en tiempo de ejecución — impulsa la resolución del modelo predeterminado y la atribución de costos en las trazas. De forma predeterminada, el plugin también se vincula al espacio de nombres de configuración ai y reconstruye el adaptador en vivo cuando un operador edita el proveedor/credenciales/modelo en Console, por lo que no se necesita reiniciar.

Las claves de API de cada proveedor provienen de las variables de entorno habituales de cada SDK:

En Console puedes pegarlas como ajustes en tiempo de ejecución en su lugar — pasan por la misma precedencia (env > settings), pero la edición en vivo significa que no hay reinicio.

Uso del servicio de IA desde el código

const ai = kernel.getService<IAIService>('ai');

// One-shot chat
const result = await ai.chat(
  [{ role: 'user', content: 'Summarize ObjectStack in two sentences.' }],
  { model: 'smart' },
);

// Structured output
const { object } = await ai.generateObject(
  [{ role: 'user', content: 'Classify this ticket: ...' }],
  { schema, model: 'fast' },
);

El servicio también expone complete(), streamChat(), embed() y listModels(). Las conversaciones se persisten como registros ai_conversations / ai_messages y se gestionan a través de la API REST (POST /api/v1/ai/chat, POST /api/v1/ai/conversations).

Uso desde agents y flows

Para IA declarativa — agents, skills y herramientas — consulta AI Agents. Los flows pueden invocar cualquier acción registrada (incluidas las acciones que envuelven una llamada a ai.chat() / ai.generateObject()) como un nodo action; consulta Flows & Automation para el contexto que lo rodea.

Embedders

El embedder convierte texto en vectores densos. Un único adaptador compatible con OpenAI, @objectstack/embedder-openai, cubre OpenAI más cualquier proveedor que exponga un endpoint /v1/embeddings compatible con OpenAI — elige uno con un preset (que establece la URL base por ti) o apunta baseUrl a un endpoint personalizado.

Configurar en código:

import { createOpenAIEmbedder } from '@objectstack/embedder-openai';

const embedder = createOpenAIEmbedder({
  preset: 'openai',
  model: 'text-embedding-3-small',
  // apiKey from OPENAI_API_KEY env if omitted
});

O elige en tiempo de ejecución desde Console → Configuration → AI → Embedder. Cambia de proveedor sin reiniciar; los vectores existentes siguen siendo consultables (puedes reindexar en segundo plano).

Conocimiento / RAG

El servicio de conocimiento orquesta la ingesta de documentos, el chunking, la generación de embeddings (a través del servicio de embedder) y la recuperación. El backend real de almacenamiento y búsqueda es conectable:

import { KnowledgeServicePlugin } from '@objectstack/service-knowledge';
import { KnowledgeRagflowPlugin } from '@objectstack/knowledge-ragflow';

kernel.use(new KnowledgeServicePlugin({ defaultTopK: 10 }));
kernel.use(new KnowledgeRagflowPlugin({
  endpoint: process.env.RAGFLOW_ENDPOINT, // e.g. http://localhost:9380
  apiKey:   process.env.RAGFLOW_API_KEY,
}));

Las bases de conocimiento indexadas se convierten en objetos de primera clase — consúltalas desde flows, muéstralas en Console, adjúntalas a asistentes de IA como contexto de recuperación.

MCP — Model Context Protocol

ObjectOS puede exponerse a sí mismo como un servidor de herramientas para agentes de IA (Claude Desktop, IDEs, agentes personalizados) a través del Model Context Protocol abierto.

import { MCPServerPlugin } from '@objectstack/plugin-mcp-server';

kernel.use(new MCPServerPlugin({
  transport: 'stdio', // or 'http'
  autoStart: true,
}));

Los agentes descubren e invocan las herramientas de ObjectOS a través de MCP — sujeto a los permisos del usuario que las llama. El servidor conecta el registro de herramientas del servicio de IA, incluidas herramientas universales como list_objects, describe_object, query_records, get_record y aggregate_data.

Garantías operativas

• Sin dependencia obligatoria de la nube. Usa Ollama para chat + el embedder de Ollama + conocimiento en memoria — totalmente aislado.
• Intercambiable en vivo. Cambia de proveedor en Console; las nuevas solicitudes usan el nuevo proveedor en la siguiente llamada. Sin reinicio.
• Configuración por tenant. Cada Environment tiene sus propios ajustes de IA. Tenant A en OpenAI, tenant B en Anthropic — el mismo runtime.
• Entradas en el registro de auditoría. Cada conversación, llamada a herramienta y solicitud al embedder puede auditarse (@objectstack/plugin-audit).
• Consciente del costo. Los recuentos de tokens y los IDs de proveedor fluyen hacia el registro de auditoría para el chargeback / análisis de costos.

Adónde ir después

• AI Agents — agents, skills y herramientas declarativos
• Flows & Automation — invoca la IA desde lógica de negocio declarativa
• Marketplace — aplicaciones impulsadas por IA en el catálogo predeterminado
• Security & Compliance — cómo se aíslan los flujos de datos de IA
• Código fuente de @objectstack/service-ai
• Código fuente de @objectstack/embedder-openai
• Código fuente de @objectstack/service-knowledge