Here is a project story for your hackathon submission, drafted from the provided README.md content and formatted in Markdown.

## Inspiration

We were inspired by the fragmentation of the current AI landscape. Users constantly have to switch between different AI services—like ChatGPT for creativity, Grok for real-time insights, or specialized models for specific tasks. This "context switching" is inefficient. We wanted to build a single, unified, and intelligent platform that eliminates this problem and acts as a true virtual assistant, capable of leveraging the best model for any given query.

## What it does

AssistMe is a next-generation, scalable AI platform built on a "Three-Pillar Architecture":

Elite AI Foundation: It integrates directly with premier models like ChatGPT and Grok for high-quality reasoning and real-time insights.
Universal Model Orchestration: Using the OpenRouter API, it intelligently selects from over 100+ different AI models, automatically routing a user's query to the best and most cost-effective model for the job.
Intelligent Knowledge Synthesis: It features a proprietary RAG (Retrieval-Augmented Generation) system, "Grokipedia," built on a PostgreSQL vector database. This allows it to learn from conversations and build a persistent, context-aware knowledge base for truly adaptive responses.

It provides a single, real-time streaming interface (using WebSockets and SSE) for all these capabilities and can even perform autonomous, multi-step tasks using an agentic engine.

## How we built it

We built a robust, high-performance backend using a modern Python stack, designed for asynchronous operations and scalability.

Backend: A lightning-fast FastAPI server handles all API requests, data validation (with Pydantic v2), and asynchronous tasks.
AI/Agent Layer: We used LangChain as the core framework to build our agentic capabilities, manage the RAG pipeline, and orchestrate calls to different models.
Data & Knowledge: PostgreSQL 15 with vector extensions serves as our primary database for sessions and user data, while ChromaDB is used for vector storage and similarity search in our RAG system.
Caching & Sessions: Redis 7+ is used for high-speed caching and managing user sessions.
Model Access: We integrated the OpenRouter SDK for universal model access and the MiniMax M2 model for specialized agentic reasoning.
Frontend: A clean, responsive Vanilla JavaScript/HTML/CSS frontend that communicates with the backend via WebSockets and Server-Sent Events (SSE) for a real-time, streaming chat experience.
Deployment: The entire application is containerized using Docker Compose for easy, one-command deployment and scalability.

Here is a simple overview of the architecture:

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Frontend UI   │    │   FastAPI API    │    │  External APIs  │
│  (Vanilla JS)   │◄──►│   Gateway        │◄──►│  (AI Services)  │
│                 │    │                 │    │                 │
│ • Streaming UI  │    │ • Agent Engine  │    │ • ChatGPT/Grok  │
│ • Real-time     │    │ • Auth Service  │    │ • OpenRouter    │
│ • Responsive    │    │ • RAG System    │    │ • GitHub API    │
└─────────────────┘    └─────────────────┘    └─────────────────┘
                              │
                              ▼
                ┌─────────────────┐    ┌─────────────────┐
                │   PostgreSQL    │    │     Redis       │
                │   Vector DB     │    │   Cache &       │
                │   Sessions      │    │   Sessions      │
                └─────────────────┘    └─────────────────┘

## Challenges we ran into

Model Orchestration: Intelligently and quickly routing a query to the "best" model among 100+ options (balancing cost, speed, and capability) was a significant engineering challenge.
Real-time Streaming: Managing multiple concurrent, long-running WebSocket and SSE connections from various external APIs and streaming them all back to a single user interface without latency was complex.
Dependency Management: The system relies on the availability of multiple external APIs (OpenAI, Grok, OpenRouter). Building resilient error handling and fallback logic was crucial to ensure a smooth user experience.
Agentic Reasoning: Configuring the LangChain agent to perform multi-step tasks reliably, without hallucinating or getting stuck in loops, required extensive prompt engineering and careful state management.

## Accomplishments that we're proud of

The Three-Pillar Architecture: We successfully integrated three distinct AI philosophies (premium models, universal orchestration, and internal RAG) into one cohesive, high-performance system.
Ultra-Low Latency Streaming: We achieved an initial response latency of <50ms for streaming, making the assistant feel incredibly responsive and "live."
True Scalability: The system is fully containerized and designed to be stateless, supporting over 10,000 concurrent users with horizontal scaling.
Context Compression Pipeline: We built a novel utility that compresses large text contexts into compact PNG images using Pillow. This allows us to bypass token limits by feeding these images to vision-enabled models (VLMs), a powerful technique for handling massive inputs.

## What we learned

We learned that the future of AI isn't just about building a single, bigger model. The real power lies in intelligent orchestration—using a network of specialized models and a robust RAG system to produce a result that is greater than the sum of its parts. We also gained a deep appreciation for the asynchronous capabilities of FastAPI and SQLAlchemy 2.0, which made building a high-throughput, real-time system entirely possible in Python.

## What's next for AssistMe-VirtualAssistant

Our roadmap is focused on expanding intelligence and enterprise-readiness.

Enhanced Intelligence (Q4 2025): We plan to integrate multi-modal input (text, voice, and images) and build more advanced reasoning chains for complex tool composition.
Enterprise Features (Q1 2026): We will add advanced analytics, custom model fine-tuning capabilities, and Enterprise SSO/directory integration.
Long-term Vision: Our ultimate goal is to evolve AssistMe into a platform for distributed AI agent networks, capable of autonomous task execution and cross-platform AI orchestration.

Built With

css
dockerfile
html
javascript
mako
python
shell

Submitted to

Google Chrome Built-in AI Challenge 2025

Created by

✏️ Describe Your Contribution
This section is where you clearly outline your specific role and the tasks you personally accomplished on the project.

Here are three high-impact options, depending on whether you worked solo, led a team, or focused on a specific component (e.g., the backend/architecture). Choose the option that best reflects your involvement, or use it as a template to write your own.

Option 1: Full-Stack Architect (If you were the primary developer/team lead)

"I served as the Lead Architect and Principal Developer for the entire platform. My primary contributions spanned all three pillars of the project:

System Architecture: Designed and implemented the complete Three-Pillar Architecture, including the stateless FastAPI API Gateway and the full Dockerized deployment workflow.

Backend & Data: Wrote the core asynchronous logic in FastAPI, configured the PostgreSQL (vector DB) and Redis integration, and established the secure JWT token-based authentication.

AI/Agent Pipeline: Built the LangChain-powered Agent Engine and developed the intelligent OpenRouter Orchestration logic for dynamic model selection.

Frontend Integration: Developed the Vanilla JavaScript client that handles WebSocket and SSE streaming to ensure the ultra-low latency, real-time user experience."

Option 2: Specialized Backend/AI Engineer (If you focused on the core logic)

"My contribution focused entirely on the backend intelligence and data orchestration. I was responsible for delivering the core features that differentiate AssistMe:

RAG System ('Grokipedia'): Designed and implemented the complete Retrieval-Augmented Generation (RAG) pipeline using LangChain and ChromaDB/PostgreSQL vector extensions to create the project's persistent, context-aware memory.

Model Routing: Developed the logic for Universal Model Orchestration, enabling the platform to dynamically select the best model from 100+ options via the OpenRouter API based on query complexity and cost.

Context Compression: Created the novel Text→Image Compression utility using the Pillow library to bypass LLM token limits for long-form content.

Performance: Ensured the system was high-performing by optimizing asynchronous database calls and setting up Redis for session management and caching."

Option 3: Full-Scope Solo Developer

"As a solo participant, I was responsible for every aspect of the AssistMe platform, from conceptualization to final deployment. My key contributions include:

Full-Stack Development: Implementing the entire application—the high-speed FastAPI backend, the data layer using PostgreSQL/Redis, and the clean Vanilla JavaScript streaming frontend.

Core Feature Development: Designing the Three-Pillar AI architecture, building the LangChain Agent for autonomous task execution, and integrating all external AI services (OpenRouter, MiniMax).

DevOps: Creating the full Docker Compose environment, writing the start.sh and deployment scripts, and configuring the CI/CD readiness."

Mangesh Bharat Raut
Software Engineer @ CES | Cloud & Full-Stack Developer | Network Solutions

Updates

Mangesh Bharat Raut started this project — Oct 31, 2025 02:24 PM EDT

Leave feedback in the comments!

Log in or sign up for Devpost to join the conversation.