Providers

import { createProvider } from '@astreus-ai/astreus';

// For OpenAI
const openaiProvider = createProvider({
  type: 'openai',
  model: 'gpt-4o-mini',
  apiKey: process.env.OPENAI_API_KEY // Optional, defaults to OPENAI_API_KEY env var
});

// For Claude (Anthropic)
const claudeProvider = createProvider({
  type: 'claude',
  model: 'claude-3-5-sonnet-20241022',
  apiKey: process.env.ANTHROPIC_API_KEY // Optional, defaults to ANTHROPIC_API_KEY env var
});

// For Gemini (Google)
const geminiProvider = createProvider({
  type: 'gemini',
  model: 'gemini-1.5-pro',
  apiKey: process.env.GOOGLE_API_KEY // Optional, defaults to GOOGLE_API_KEY env var
});

// For Ollama (local models)
const ollamaProvider = createProvider({
  type: 'ollama',
  baseUrl: "http://localhost:11434",
  model: "llama3.1"
});

// Get the default model
const defaultModel = provider.getDefaultModel();

// List available models
const availableModels = provider.listModels();

// Get a specific model
const gpt4 = provider.getModel('gpt-4o');

import { createAgent, createProvider, createMemory, createDatabase } from '@astreus-ai/astreus';

async function createAgentWithProvider() {
  const db = await createDatabase();
  const memory = await createMemory({ database: db });
  
  // Create provider
  const provider = createProvider({
    type: 'openai',
    model: 'gpt-4o-mini',
    apiKey: process.env.OPENAI_API_KEY
  });

  // Create agent with provider
  const agent = await createAgent({
    name: 'MyAgent',
    provider: provider,
    memory: memory,
    systemPrompt: "You are a helpful AI assistant."
  });

  return agent;
}

// Get a model from the provider
const model = provider.getModel('gpt-4o-mini');

// Generate a completion
const messages = [
  { role: 'system', content: 'You are a helpful assistant.' },
  { role: 'user', content: 'What is the capital of France?' }
];

const completion = await model.complete(messages);
console.log(completion); // "The capital of France is Paris."

// Generate embeddings for text content (OpenAI only)
const text = "This is a sample text for embedding generation";
const embedding = await provider.generateEmbedding(text);

// The embedding is a vector (number array) that can be used for semantic search
console.log(`Generated embedding with ${embedding.length} dimensions`);

// List available models
const models = provider.listModels();
console.log('Available models:', models);

// Get default model name
const defaultModelName = provider.getDefaultModel();
console.log('Default model:', defaultModelName);

// Get a specific model instance
const specificModel = provider.getModel('gpt-4o');

// Get provider type
console.log('Provider type:', provider.type);

// Get embedding model name
const embeddingModel = provider.getEmbeddingModel();
console.log('Embedding model:', embeddingModel);

// Generate embeddings
const embedding = await provider.generateEmbedding("Sample text");
console.log('Embedding dimensions:', embedding?.length);

# Global Model Configuration
MODEL_NAME=gpt-4o-mini           # Model name for any provider
TEMPERATURE=0.7                  # Model temperature (0.0 - 1.0)
MAX_TOKENS=2048                 # Maximum tokens per response
EMBEDDING_MODEL=text-embedding-3-small  # Embedding model

# Switch providers easily by changing MODEL_NAME:
# MODEL_NAME=claude-3-haiku-20240307     # For Claude
# MODEL_NAME=gemini-1.5-flash           # For Gemini  
# MODEL_NAME=llama3.2                   # For Ollama

# Provider API Keys
OPENAI_API_KEY=your_openai_api_key
ANTHROPIC_API_KEY=sk-ant-your_anthropic_api_key
GOOGLE_API_KEY=your_google_api_key

# Optional Provider Base URLs
OPENAI_BASE_URL=https://api.openai.com/v1
ANTHROPIC_BASE_URL=https://api.anthropic.com
GOOGLE_BASE_URL=https://generativelanguage.googleapis.com
OLLAMA_BASE_URL=http://localhost:11434

import { createAgent, createProvider, createMemory, createDatabase } from '@astreus-ai/astreus';

async function createMultiProviderSystem() {
  const db = await createDatabase();
  const memory = await createMemory({ database: db });

  // Fast provider for simple tasks
  const fastProvider = createProvider({
    type: 'openai',
    model: 'gpt-4o-mini'
  });

  // Powerful provider for complex tasks
  const powerfulProvider = createProvider({
    type: 'claude',
    model: 'claude-3-5-sonnet-20241022'
  });

  // Creative provider for content generation
  const creativeProvider = createProvider({
    type: 'gemini',
    model: 'gemini-1.5-pro'
  });

  // Local provider for privacy-sensitive tasks
  const localProvider = createProvider({
    type: 'ollama',
    model: 'llama3.1',
    baseUrl: 'http://localhost:11434'
  });

  // Create agents with different providers
  const fastAgent = await createAgent({
    name: 'FastAgent',
    provider: fastProvider,
    memory: memory,
    systemPrompt: "You provide quick, concise responses."
  });

  const powerfulAgent = await createAgent({
    name: 'PowerfulAgent',
    provider: powerfulProvider,
    memory: memory,
    systemPrompt: "You provide detailed, comprehensive responses with careful reasoning."
  });

  const creativeAgent = await createAgent({
    name: 'CreativeAgent',
    provider: creativeProvider,
    memory: memory,
    systemPrompt: "You are a creative assistant that generates engaging content."
  });

  const localAgent = await createAgent({
    name: 'LocalAgent',
    provider: localProvider,
    memory: memory,
    systemPrompt: "You are a privacy-focused assistant running locally."
  });

  return { fastAgent, powerfulAgent, creativeAgent, localAgent };
}