A modern, extensible multi-agent AI system built with Next.js, TypeScript, and modular architecture. PolarisAI provides a reasoning-based approach to AI interactions, supporting multiple LLM providers and designed for easy extension with new agents.

User: "How does the reasoning system work?"

🤖 PolarisAI: Analyzing your question about the reasoning system...

💭 REASONING PIPELINE:
1. ANALYZE: Understanding your intent about system architecture
2. PLAN: Structuring response about reasoning workflow
3. EXECUTE: Explaining the four-phase pipeline
4. REFLECT: Ensuring comprehensive coverage

✨ RESPONSE:
The reasoning system follows a structured pipeline:
- Analyze → Plan → Execute → Reflect
- Each agent processes input through these phases
- Confidence scoring and reasoning explanations included
- Memory system maintains context across conversations

Confidence: 92%

• Multi-Agent System: Extensible framework for specialized AI agents
• Reasoning Pipeline: Analyze → Plan → Execute → Reflect workflow
• Provider Agnostic: Support for OpenAI, Ollama, and extensible to other providers
• Local & Remote Models: Run with local models (Ollama) or cloud APIs (OpenAI, Anthropic)
• Memory System: Persistent conversation memory and learning capabilities
• Tool Integration: Extensible tool system for agent capabilities

• General Assistant: Versatile helper for various tasks and questions
• Specialized Tools: Text analysis, brainstorming, step-by-step planning
• Reasoning Display: Shows confidence levels and thought processes

• TypeScript: Fully typed for better development experience
• Next.js 15: Modern React framework with App Router
• Tailwind CSS: Utility-first styling
• Modular Design: Clean separation of concerns
• GDPR Compliance: Built-in privacy features and data protection

• Node.js 18+ or Bun (recommended)
• Optional: Ollama for local models

1. Clone the repository

   git clone git@github.com:jakubkunert/PolarisAI.git
   cd polaris-ai

2. Install dependencies

   bun install
   # or
   npm install

3. Start the development server

   bun dev
   # or
   npm run dev

4. Open in browser Navigate to http://localhost:3000

1. Get an API key from OpenAI
2. In the web interface, click "Settings"
3. Select "OpenAI" as provider
4. Enter your API key
5. Start chatting!

1. Install Ollama: https://ollama.ai
2. Pull a model: ollama pull llama3.2
3. Start Ollama service: ollama serve
4. The system will auto-detect Ollama and use it

┌─────────────────────────────────────────┐
│            Frontend (Next.js)           │
├─────────────────────────────────────────┤
│              API Layer                  │
├─────────────────────────────────────────┤
│          Agent Orchestrator             │
├─────────────────────────────────────────┤
│    Agent 1    │    Agent 2    │  ...    │
├─────────────────────────────────────────┤
│           Model Providers               │
│  OpenAI │ Ollama │ Anthropic │ ...      │
└─────────────────────────────────────────┘

• BaseModelProvider: Abstract base class for all providers
• OpenAIProvider: OpenAI GPT integration
• OllamaProvider: Local model support
• ModelManager: Handles provider registration and routing

• BaseAgent: Abstract base class for all agents
• BasicTaskPlanner: Implements the reasoning pipeline
• GeneralAssistantAgent: General-purpose assistant
• Tool System: Extensible capabilities framework

• Comprehensive TypeScript interfaces
• GDPR-compliant data structures
• Agent and model abstractions

Each agent follows a structured reasoning process:

1. Analysis: Understand user intent and context
2. Planning: Create step-by-step action plan
3. Execution: Carry out the plan with tools
4. Reflection: Learn from the interaction

POST /api/chat

// Request
{
  "message": "string",
  "provider": "openai" | "ollama" | string,
  "apiKey": "string" // Optional, for remote providers
}

// Response
{
  "success": boolean,
  "response": {
    "id": "string",
    "content": "string",
    "confidence": number, // 0-1
    "reasoning": "string",
    "timestamp": "string",
    "metadata": object
  },
  "agent": {
    "id": "string",
    "name": "string",
    "status": object
  }
}

GET /api/chat

Returns system status and available providers.

polaris-ai/
├── src/
│   ├── app/                    # Next.js app router
│   │   ├── api/chat/          # API endpoints
│   │   └── page.tsx           # Main interface
│   ├── core/                  # Core system
│   │   ├── agents/            # Agent implementations
│   │   ├── models/            # Model providers
│   │   └── types/             # TypeScript definitions
│   ├── components/            # UI components
│   ├── lib/                   # Utilities
│   └── hosted/                # Premium features
├── docs/                      # Documentation
└── README.md

1. Create agent class

   // src/core/agents/my-agent.ts
   import { BaseAgent } from './base-agent';
   
   export class MyAgent extends BaseAgent {
     constructor(modelProvider: ModelProvider, modelConfig: ModelConfig) {
       super(
         'my-agent',
         'My Agent',
         'Description of what this agent does',
         ['capability1', 'capability2'],
         'System prompt for the agent...',
         modelProvider,
         modelConfig
       );
     }
   
     createMemory(): LongTermMemory {
       // Implement memory structure
     }
   
     createPlanner(): TaskPlanner {
       // Implement or use existing planner
     }
   }

2. Register with orchestrator

   // In your orchestrator
   const agent = new MyAgent(modelProvider, modelConfig);
   orchestrator.registerAgent(agent);

1. Implement provider

   // src/core/models/my-provider.ts
   import { BaseModelProvider } from './base-provider';
   
   export class MyProvider extends BaseModelProvider {
     constructor() {
       super('my-provider', 'My Provider', 'remote');
     }
   
     async authenticate(apiKey?: string): Promise<boolean> {
       // Implement authentication
     }
   
     async generateResponse(prompt: string, config: ModelConfig): Promise<string> {
       // Implement response generation
     }
   
     // ... other required methods
   }

2. Register with model manager

   // In model manager
   modelManager.registerProvider(new MyProvider());

• Local Processing: Run everything on your own infrastructure
• Data Control: You own and control all your data
• No Tracking: No telemetry or data collection
• Open Source: Full transparency in all operations

• Self-Hosted: Complete control over your environment
• API Key Security: Secure storage of model provider credentials
• Audit Trail: Full visibility into all operations
• Customizable: Modify security to your requirements

We welcome contributions to PolarisAI! Please read our Contributing Guide for details on:

• Development setup and workflow
• Git flow and commit conventions
• Code standards and testing
• Pull request process
• Adding new features and agents

1. Fork the repository
2. Set up your development environment (see CONTRIBUTING.md)
3. Create a feature branch: git checkout -b feature/your-feature
4. Make your changes and add tests
5. Submit a pull request

• Language: TypeScript
• Framework: Next.js 15
• Styling: Tailwind CSS
• Runtime: Bun (recommended) or Node.js 18+
• Database: Optional (PostgreSQL for persistence)

For detailed development instructions, see CONTRIBUTING.md.

• ✅ Multi-agent reasoning system
• ✅ OpenAI and Ollama provider support
• ✅ Web interface with chat functionality
• ✅ Development workflow and contribution guidelines

• Enhanced Agent Capabilities

  • Specialized agents for different domains
  • Advanced reasoning and planning
  • Multi-agent collaboration

• Extended Model Support

  • Anthropic Claude integration
  • Google Gemini support
  • Custom model providers

• User Experience

  • Voice interaction support
  • Mobile-responsive design
  • Advanced conversation management

• Enterprise Features

  • User authentication and management
  • Team collaboration tools
  • Advanced analytics and monitoring

• Bug Reports: Use our bug report template
• Feature Requests: Use our feature request template
• Questions: Start a GitHub Discussion
• Security Issues: Please report privately to [security contact]

This project is licensed under the MIT License - see the LICENSE file for details.

• Thanks to all contributors who help improve PolarisAI
• Inspired by the open-source AI community
• Built with amazing tools and frameworks from the JavaScript ecosystem

Ready to build the future of AI agents? Check out our Contributing Guide and join the community! 🚀