Repository files navigation

A comprehensive AI-powered platform for football statistics analysis and real-time insights using LangChain v3, multiple LLM models, and advanced agent orchestration.

• OpenAI GPT-4 Turbo: Primary model for complex analysis and reasoning
• Groq Mixtral-8x7b: Used for real-time processing and initial query routing
• Model Selection Logic: Automatic selection based on task complexity and requirements

• Orchestrates the entire query processing pipeline
• Manages agent delegation and task routing
• Handles fallback scenarios and error recovery
• Maintains processing state and debugging information

• Analysis Agent: Historical data analysis and statistical comparisons
• Realtime Agent: Live scores and current match statistics
• Enhancement Agent: Query refinement and context enrichment
• Security Agent: Query validation and scope verification

• Vector store integration for semantic search
• Redis-based document storage
• Dynamic context retrieval based on query relevance
• Automatic document embedding and indexing
• Support for multiple document types (team stats, player stats, tournament data)

• Redis-based Chat History: Persistent conversation storage
• Vector Store Memory: Efficient similarity search
• Context Window Management: Handles long-running conversations
• Session Management: User-specific conversation tracking

• Football Data Tool: Historical statistics and records
• Live Scores Tool: Real-time match data
• Stats Calculator Tool: Advanced statistical analysis
• Timeframe Tool: Temporal data processing
• Dynamic Tool Loading: Automatic tool discovery and registration

• Interactive command-line interface
• Real-time processing feedback
• Step-by-step execution visibility
• Debug information display
• Color-coded output for better readability

• Express-based HTTP server
• JSON request/response format
• Health check endpoints
• Error handling middleware
• Rate limiting and security features

1. Security Validation
2. Context Retrieval
3. Query Enhancement
4. Agent Selection
5. Data Processing
6. Response Generation

• JSON-formatted responses
• Confidence scoring
• Source attribution
• Processing metadata
• Error tracing

• Graceful degradation
• Fallback mechanisms
• Detailed error reporting
• Recovery strategies

src/agents/├── base.agent.ts         # Base agent implementation├── supervisor.agent.ts   # Main orchestration agent├── internal/            # Internal processing agents└── user/               # User-facing agents

src/tools/├── index.ts            # Tool registry├── football.tool.ts    # Football data tool├── live.tool.ts        # Real-time data tools└── stats.tool.ts       # Statistical analysis tools

src/services/├── rag.service.ts      # RAG implementation├── redis.service.ts    # Memory management└── cache.service.ts    # Response caching

1. Query Input (CLI/API)
2. Security Validation
3. Context Retrieval (RAG)
4. Query Enhancement
5. Agent Selection
6. Tool Execution
7. Response Generation
8. Memory Update

• Node.js >= 18
• Redis server
• OpenAI API key
• Groq API key

# Clone the repositorygit clone<repository-url># Install dependenciesnpm install# Configure environment variablescp .env.example .env# Edit .env with your API keys# Start Redisdocker-compose up -d# Run the applicationnpm run start

# Start the CLInpm run cli# Example queries:-"How did Manchester United perform in 2023?"-"Who was Liverpool's top scorer last season?"-"Compare Arsenal and Chelsea's recent performance"

# Query endpointPOST /query{"query":"Tell me about Manchester United's performance"}# Health checkGET /health

• OPENAI_API_KEY: OpenAI API key
• GROQ_API_KEY: Groq API key
• REDIS_URL: Redis connection string
• PORT: API server port

• Adjust temperature and other parameters inconfig/config.ts
• Configure model selection logic insupervisor.agent.ts

• Each agent has specific responsibilities and capabilities
• Agents can be extended or modified for custom use cases
• New agents can be added by implementing the base agent interface

• Tools provide specific functionalities
• New tools can be added by implementing the tool interface
• Tools are automatically discovered and registered

• RESTful endpoints for query processing
• JSON request/response format
• Error codes and handling

• Fork the repository
• Create a feature branch
• Submit a pull request

MIT License

• LangChain team for the excellent framework
• OpenAI and Groq for their LLM APIs
• Redis for memory management capabilities