ARIA is a full-stack personal knowledge assistant that ingests multiple knowledge sources and allows users to query them through an intelligent chat interface powered by Retrieval-Augmented Generation (RAG).
ARIA can process:
- 📄 PDF documents
▶️ YouTube video transcripts- 🧑💻 GitHub repositories
The system converts these sources into vector embeddings stored in a semantic database and retrieves the most relevant information to generate contextual answers.
ARIA aims to function as a personal AI knowledge brain, allowing users to build a searchable memory of their documents, repositories, and learning resources.
The interface provides a clean, intuitive design featuring:
- Knowledge Base Management: Upload PDFs, paste GitHub repo links, and index YouTube videos
- Interactive Chat: Real-time conversation with your personal AI brain
- Status Indicators: Voice standby and reply status monitoring
- Indexed History: Context explorer showing all indexed knowledge sources
ARIA can ingest knowledge from multiple sources including:
- 📄 PDF documents
▶️ YouTube transcripts- 🧑💻 GitHub repositories
Each source is processed and converted into embeddings for semantic retrieval.
ARIA answers questions by retrieving the most relevant knowledge chunks from the vector database and passing them to a language model for contextual response generation.
This ensures:
- grounded answers
- traceable sources
- reduced hallucinations
Users can review all indexed knowledge sources through a knowledge ledger interface and remove individual sources when needed.
This allows dynamic control of the knowledge base.
All document chunks are embedded using HuggingFace embeddings and stored in a Chroma vector database, enabling fast semantic search across all ingested knowledge.
ARIA can ingest GitHub repositories and index their source files.
To avoid excessively long indexing operations, ingestion is intentionally limited by:
- maximum file count
- maximum file size
ARIA uses a Retrieval-Augmented Generation pipeline.
User
│
▼
Frontend (Next.js)
│
▼
FastAPI Backend
│
├── Ingestion Pipeline
│ ├ PDF parsing
│ ├ GitHub repository crawling
│ └ YouTube transcript extraction
│
├── Embedding Generation
│ └ HuggingFace embeddings
│
├── Vector Storage
│ └ Chroma database
│
▼
Retriever
│
▼
LLM (Groq)
│
▼
Generated Response
- Next.js
- React
- TypeScript
- Tailwind CSS
- FastAPI
- LangChain
- Chroma Vector Database
- HuggingFace Embeddings
- Groq LLM API
- Retrieval Augmented Generation (RAG)
.
├── backend/
│ ├── main.py
│ ├── requirements.txt
│ ├── services/
│ │ ├── ingestion.py
│ │ └── rag.py
│ └── .env.example
│
├── frontend/
│ ├── package.json
│ └── src/
│
└── README.md
Create a .env file in the backend directory based on .env.example.
GROQ_API_KEY=
DATA_DIR=
GROQ_CHAT_MODEL=
CHROMA_DB_DIR=
UPLOAD_DIR=
CORS_ALLOWED_ORIGINS=
GITHUB_TOKEN=
GITHUB_MAX_FILES=
GITHUB_MAX_FILE_BYTES=
cd backend
python -m venv venv
venv\Scripts\activate
pip install -r requirements.txt
python -m uvicorn main:app --host 127.0.0.1 --port 8000
cd frontend
npm install
npm run dev
The frontend expects the backend at:
http://localhost:8000
unless overridden using:
NEXT_PUBLIC_API_URL
The backend can be deployed to Render as a Python web service.
Recommended service settings:
- Root Directory:
backend - Build Command:
pip install -r requirements.txt - Start Command:
python -m uvicorn main:app --host 0.0.0.0 --port $PORT - Health Check Path:
/health
Recommended environment variables:
GROQ_API_KEYGROQ_CHAT_MODELGITHUB_TOKEN(optional)DATA_DIR=./storage
This repo is currently configured for Render free tier, so it does not use a persistent disk.
That means uploaded files, indexed Chroma data, and saved memory can be lost whenever the service restarts, redeploys, or sleeps.
If you later move to a paid Render plan, you can attach a persistent disk and set DATA_DIR to the disk mount path.
If your frontend runs on a domain other than the default Vercel URL in backend/main.py, add it with:
CORS_ALLOWED_ORIGINS=https://your-frontend-domain.com
GitHub repositories are indexed with limits to prevent extremely long ingestion jobs.
This keeps indexing practical and avoids excessive memory consumption.
YouTube transcript ingestion is currently experimental.
Possible issues include:
- transcript extraction failure
- unavailable transcripts
- empty ingestion results
Because of this, YouTube ingestion should not yet be considered fully reliable.
The backend can run on Render or similar platforms, but it works best with a persistent disk and enough RAM for embedding generation.
ARIA performs several compute-intensive tasks including:
- document parsing
- chunk generation
- embedding creation
- vector indexing
- retrieval orchestration
Most free-tier cloud platforms impose limitations on:
- memory
- CPU resources
- execution time
- persistent storage
Because of these infrastructure constraints, low-tier or fully ephemeral instances may still struggle with cold starts, indexing speed, and data persistence.
ARIA includes an experimental voice input interface.
Voice interaction is not yet fully reliable and may fail due to:
- browser speech recognition inconsistencies
- microphone permission handling
- device compatibility differences
- speech-to-text accuracy variations
For now, text input is recommended for interacting with ARIA.
Never commit:
.envfiles- API keys
- GitHub tokens
Always use .env.example as the public configuration template.
If credentials have been exposed in version control or screenshots, rotate them immediately.
Planned improvements include:
- ☁️ scalable backend deployment
- 📺 improved YouTube ingestion reliability
- 🧠 persistent cloud vector storage
- 📄 improved document chunking
- 📚 better source attribution
- ⚡ real-time streaming responses
- 🎙️ improved voice interaction
Copyright (c) 2026 tripcoded All rights reserved.
This repository, its source code, documentation, design, and associated materials are proprietary.
No part of this repository may be copied, reproduced, distributed, modified, sublicensed, published, or used for commercial or non-commercial redistribution without prior explicit written permission from the copyright holder.