Model Providers

# Instala solo el provider que necesitas
npm install @foxframework/model-openai
npm install @foxframework/model-anthropic
npm install @foxframework/model-ollama

import { OpenAIProvider } from '@foxframework/model-openai';
 
const model = new OpenAIProvider({
  apiKey: process.env.OPENAI_API_KEY,
  model: 'gpt-4o',              // default: gpt-4o
  baseUrl: 'https://api.openai.com/v1',  // custom endpoint (Azure, proxies)
  organization: 'org-...',      // opcional
});

const result = await model.complete([
  { role: 'system', content: 'You are a helpful assistant.' },
  { role: 'user', content: 'What is 2 + 2?' },
]);
console.log(result.content); // "4"
console.log(result.usage);   // { promptTokens, completionTokens, totalTokens }

for await (const chunk of model.stream(messages)) {
  process.stdout.write(chunk);
}

const result = await model.complete(messages, {
  tools: [myTool],
  toolChoice: 'auto',
});
 
if (result.toolCalls) {
  for (const call of result.toolCalls) {
    const output = await myTool.execute(call.arguments);
  }
}

import { AnthropicProvider } from '@foxframework/model-anthropic';
 
const model = new AnthropicProvider({
  apiKey: process.env.ANTHROPIC_API_KEY,
  model: 'claude-opus-4-5',    // default: claude-opus-4-5
  maxTokens: 4096,
});

const result = await model.complete([
  { role: 'user', content: 'Explain quantum entanglement simply.' },
]);

const result = await model.complete([
  { role: 'system', content: 'You are a physics professor.' },
  { role: 'user', content: 'Explain quantum entanglement.' },
]);

import { OllamaProvider } from '@foxframework/model-ollama';
 
const model = new OllamaProvider({
  baseUrl: 'http://localhost:11434', // default
  model: 'llama3.2',
  keepAlive: '5m',     // tiempo que el modelo permanece cargado
  options: {
    temperature: 0.7,
    num_predict: 512,
  },
});

# Instalar Ollama
curl -fsSL https://ollama.ai/install.sh | sh
 
# Descargar un modelo
ollama pull llama3.2
ollama pull mistral
ollama pull codellama

for await (const chunk of model.stream(messages)) {
  process.stdout.write(chunk);
}

import { ReActAgent } from '@foxframework/core/agents';
import { OpenAIProvider } from '@foxframework/model-openai';
// o: import { AnthropicProvider } from '@foxframework/model-anthropic';
// o: import { OllamaProvider } from '@foxframework/model-ollama';
 
const agent = new ReActAgent({
  model: new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY }),
  tools: [myTool],
});

import { IModelProvider, Message, CompletionResult } from '@foxframework/core/agents';
 
class MyCustomProvider implements IModelProvider {
  async complete(messages: Message[]): Promise<CompletionResult> {
    const response = await fetch('https://my-llm-api.com/chat', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ messages }),
    });
    const data = await response.json();
    return {
      content: data.text,
      usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
    };
  }
 
  async *stream(messages: Message[]): AsyncGenerator<string> {
    // implementación opcional
  }
}

npm install @foxframework/vector-pinecone    # Pinecone
npm install @foxframework/vector-weaviate   # Weaviate
npm install @foxframework/vector-chroma     # ChromaDB

import { PineconeProvider } from '@foxframework/vector-pinecone';
 
const provider = new PineconeProvider({
  apiKey: process.env.PINECONE_API_KEY!,
  indexHost: process.env.PINECONE_INDEX_HOST!, // from Pinecone console
  embed: async (text) => myEmbeddingFn(text),  // optional: auto-embed on search/upsert
});
 
// Search
const results = await provider.search('climate change solutions', { topK: 5 });
 
// Upsert (requires embed function)
await provider.upsert('doc-1', 'Fox Framework is a TypeScript web framework.', {
  source: 'docs',
  version: '1.4',
});

import { WeaviateProvider } from '@foxframework/vector-weaviate';
 
const provider = new WeaviateProvider({
  url: 'https://my-cluster.weaviate.network',
  className: 'Document',          // Weaviate class/collection
  apiKey: process.env.WEAVIATE_API_KEY,
  textProperty: 'text',           // property holding document content (default: 'text')
});
 
const results = await provider.search('renewable energy', { topK: 3, minScore: 0.7 });

import { ChromaProvider } from '@foxframework/vector-chroma';
 
const provider = new ChromaProvider({
  url: 'http://localhost:8000',
  collection: 'my-docs',
  embed: async (texts) => myBatchEmbedFn(texts), // required for search + upsert
});
 
const results = await provider.search('Fox Framework routing', { topK: 5 });

import { createVectorSearchTool } from '@foxframework/core/agents/tools';
import { PineconeProvider } from '@foxframework/vector-pinecone';
import { ReActAgent } from '@foxframework/core/agents';
 
const tool = createVectorSearchTool(
  new PineconeProvider({ apiKey: '...', indexHost: '...' }),
  { label: 'knowledge_base', defaultTopK: 5 },
);
 
const agent = new ReActAgent({ model, tools: [tool] });
const result = await agent.run('What does Fox Framework say about middleware?');