convez.ai
PluginIntegração & APIsIntermediário
TEJA4704

Unified LLM Engine

TEJA4704/unified-llm-engine

Abstração unificada para múltiplos LLMs com fallbacks e rastreamento de custos

Ver no GitHub
InicialPluginScore · de 0 a 100

Camada de abstração multi-provider para LLMs com API unificada, fallbacks automáticos e rastreamento de custos. Suporta OpenAI, Anthropic, Gemini, Azure, AWS Bedrock e Ollama com roteamento inteligente, cache de respostas e execução async-first para alta performance.

Instalação

$npx convez-ai TEJA4704/unified-llm-engine

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 10 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Reduzir dependência de um único provider com fallbacks automáticos
  • Rastrear gastos e otimizar custos de chamadas a LLMs
  • Implementar aplicações resilientes que alternam entre providers

Veredito

Plugin robusto e bem arquitetado para abstrair complexidade multi-provider. Particularmente valioso para aplicações em produção que precisam de resiliência e controle de custos, embora exija configuração cuidadosa de credenciais.

README

A tradução para o português deste README ainda está na fila.

⚡ Unified LLM Engine

Python 3.10+ License: MIT

Multi-provider LLM abstraction layer with unified API, automatic fallbacks, cost tracking, and intelligent routing across OpenAI, Anthropic, Google, and more.


🌟 Features

  • Unified API - Same interface for all providers
  • 6+ Providers - OpenAI, Anthropic, Gemini, Azure, AWS Bedrock, Ollama
  • Automatic Fallbacks - Seamless failover between providers
  • Cost Tracking - Token usage and cost monitoring
  • Response Caching - Reduce costs with intelligent caching
  • Streaming Support - Real-time response streaming
  • Async-First - Built for high-performance async execution

🏗️ Architecture

┌─────────────────────────────────────────────────────────────────┐
│                     Unified LLM Engine                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │                   LLM Router                              │    │
│  │  • Model Selection  • Load Balancing  • Fallback Logic   │    │
│  └─────────────────────────────────────────────────────────┘    │
│                              ↓                                   │
│  ┌────────────┐  ┌────────────┐  ┌────────────┐  ┌──────────┐  │
│  │  OpenAI    │  │ Anthropic  │  │  Gemini    │  │  Ollama  │  │
│  │  Provider  │  │  Provider  │  │  Provider  │  │ Provider │  │
│  └────────────┘  └────────────┘  └────────────┘  └──────────┘  │
│                              ↓                                   │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │              Response Cache + Cost Tracker               │    │
│  └─────────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────────┘

🚀 Quick Start

git clone https://github.com/yourusername/unified-llm-engine.git
cd unified-llm-engine
pip install -r requirements.txt

Basic Usage

from llm_engine import LLMEngine

# Initialize with multiple providers
engine = LLMEngine()

# Use like any single LLM
response = await engine.generate(
    prompt="Explain quantum computing in simple terms",
    model="gpt-4",  # or "claude-3-opus", "gemini-pro", etc.
    temperature=0.7,
    max_tokens=500
)

print(response.content)
print(response.usage)  # Token counts
print(response.cost)   # Estimated cost

Provider-Specific

from llm_engine.providers import OpenAIProvider, AnthropicProvider

# Use specific provider
openai = OpenAIProvider(api_key="sk-...")
response = await openai.generate(prompt="Hello!", model="gpt-4")

# With fallback
anthropic = AnthropicProvider(api_key="sk-ant-...")
response = await engine.generate(
    prompt="Hello!",
    model="gpt-4",
    fallback_models=["claude-3-opus", "gemini-pro"]
)

📚 Providers

ProviderModelsStreamingEmbeddings
OpenAIGPT-4, GPT-3.5✅✅
AnthropicClaude 3 Opus/Sonnet/Haiku✅❌
GeminiGemini Pro, Gemini Flash✅✅
Azure OpenAIGPT-4, GPT-3.5✅✅
AWS BedrockClaude, Titan✅✅
OllamaLlama, Mistral, etc.✅✅

📁 Project Structure

unified-llm-engine/
├── llm_engine/
│   ├── __init__.py
│   ├── core/
│   │   └── engine.py
│   └── providers/
│       ├── base_provider.py
│       ├── openai_provider.py
│       ├── anthropic_provider.py
│       ├── gemini_provider.py
│       └── exceptions.py
├── examples/
├── tests/
├── requirements.txt
└── README.md

⚙️ Configuration

# .env
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GEMINI_API_KEY=...

# Optional
DEFAULT_MODEL=gpt-4
ENABLE_CACHING=true
CACHE_TTL=3600

📊 Cost Tracking

from llm_engine import LLMEngine

engine = LLMEngine(track_costs=True)

# Make requests...
response = await engine.generate(...)

# Get cost summary
print(engine.get_cost_summary())
# {
#   "total_cost": 0.054,
#   "total_tokens": 1250,
#   "by_model": {"gpt-4": 0.050, "claude-3-sonnet": 0.004}
# }

📄 License

MIT License - See LICENSE


📬 Contact

Ravi Teja K - AI/ML Engineer

Ver o original no GitHub

Bom para

Relacionados