NEXUS — Personal Learning Agent
Inspiration
I wanted to build an AI that was more than a chatbot.
When I study, information is usually scattered across notes, documents, conversations, and different websites. A normal chatbot can answer questions, but it doesn't necessarily know my material, remember what we were working on, or help me turn that material into an actual learning process.
That led me to the idea behind NEXUS: a personal AI agent that connects conversation, memory, knowledge, and learning tools into one system.
Instead of simply asking an AI a question, I wanted to be able to give NEXUS my own material and say:
"Help me understand this."
From there, NEXUS can retrieve relevant information, use conversation context, explain concepts, summarize material, create quizzes, and help build study plans.
What is NEXUS?
NEXUS is a personal AI learning agent designed to work with the user's own knowledge and context.
It combines:
Conversation memory — keeps track of previous messages and context. Personal knowledge base — stores documents and their semantic embeddings for retrieval. Semantic search — finds the most relevant pieces of stored knowledge instead of relying only on keyword matching. Study material — allows users to provide files and learning material to work with. Learning assistance — explains concepts, summarizes information, creates quizzes, and builds study plans. Agent tools — gives NEXUS access to tools for tasks such as time, text analysis, and task management. Workflows — provides a foundation for multi-step autonomous tasks.
The goal isn't to replace learning.
The goal is to make the AI work with the learner's own information.
How It Works
At a high level, NEXUS follows a pipeline like this:
USER
│
▼
NEXUS FRONTEND
│
▼
FASTAPI API
│
▼
NEXUS AGENT
│
▼
NEXUS BRAIN
/ │ \
/ │ \
▼ ▼ ▼
MEMORY KNOWLEDGE TOOLS
│
▼
VECTOR SEARCH
│
▼
GEMINI MODEL
│
▼
RESPONSE
When a user asks a question, NEXUS first considers the available context.
It searches the personal knowledge base using embeddings and cosine similarity, retrieves relevant chunks, combines them with conversation history and stored memories, and then provides that context to the language model.
This means the model isn't expected to magically know everything about the user's documents. NEXUS first retrieves the information that is actually relevant.
Knowledge Retrieval
One of the most important parts of NEXUS is its knowledge system.
Documents are broken into smaller chunks and embedded into vectors. When the user asks a question, NEXUS generates an embedding for the query and compares it against the stored knowledge using cosine similarity.
Conceptually:
$$ \text{similarity}(A,B)= \frac{A\cdot B}{|A||B|} $$
The highest-scoring relevant chunks are then provided to NEXUS as context.
This gives NEXUS a simple retrieval-augmented generation pipeline:
Document
↓
Chunking
↓
Embeddings
↓
Knowledge Store
↓
User Question
↓
Query Embedding
↓
Similarity Search
↓
Relevant Knowledge
↓
AI Response
This was especially important to me because I wanted NEXUS to work with my information, rather than treating every conversation as completely separate from everything I've previously given it.
Learning Features
NEXUS is designed around learning rather than just answering questions.
For example, a user can ask NEXUS to:
Explain
Break a difficult concept down into a clearer explanation.
Summarize
Turn a large amount of study material into a concise summary containing the main ideas, important terms, and formulas.
Quiz
Generate an interactive quiz from relevant knowledge and ask questions one at a time.
Study Plan
Turn a topic into a structured study plan with learning, practice, review, and understanding checks.
The idea is to move from:
"Give me the answer."
toward:
"Help me understand this."
Agentic Architecture
A major goal of this project was learning what actually makes an AI system agentic.
NEXUS isn't just a frontend connected directly to an LLM.
The system contains multiple layers:
Frontend
│
▼
FastAPI
│
▼
NexusAgent
│
├── NexusBrain
│ ├── Gemini
│ ├── Memory
│ ├── Knowledge Retrieval
│ └── Tools
│
└── NexusWorkflow
└── Multi-step tasks
The brain decides how to handle a request, retrieves relevant knowledge, incorporates memory, and can use available tools.
This architecture also makes NEXUS extensible. New tools and capabilities can be added without rebuilding the entire application.
How I Built It
NEXUS was built as a full-stack application.
Frontend
- HTML
- CSS
- JavaScript
The interface was intentionally designed to be simple and focused instead of looking like a generic AI dashboard.
It includes:
- conversation history
- chat interface
- knowledge workspace
- memory workspace
- statistics
- file interaction
- responsive layout
Backend
- Python
- FastAPI
- Gemini API
The backend exposes API endpoints for chat, memory, knowledge, statistics, and workflows.
AI / Knowledge
- Gemini
- Embeddings
- Vector similarity search
- Retrieval-augmented generation
- Persistent knowledge storage
The project is structured into separate modules for the agent, brain, memory, tools, workflows, embeddings, knowledge storage, and API server.
Challenges
One of the hardest parts was getting all of the individual components to work together.
It wasn't enough to make an AI response appear on the screen. I had to connect the frontend to the backend, the backend to the agent, the agent to memory and knowledge retrieval, and the knowledge system to embeddings.
I also ran into API and dependency problems while developing NEXUS. At different points, model availability, API quotas, Python packages, embeddings, and other dependencies caused failures.
These problems taught me an important lesson:
Building an AI application is much more than calling an AI API.
The surrounding engineering matters just as much.
I also had to design fallback behavior so that when the AI service isn't available, NEXUS can still expose information from its local knowledge system instead of completely failing.
What I Learned
This project taught me a lot about building practical AI systems.
I learned how to:
- build and structure a FastAPI backend
- connect a frontend to an AI backend
- work with the Gemini API
- generate and store embeddings
- implement semantic search
- build retrieval-augmented generation
- design conversational memory
- structure an AI agent around tools
- create multi-step workflows
- handle API failures and quotas
- design an interface around an actual product rather than just a technical demo
Most importantly, I learned that an agent is not just a language model.
The interesting part is the system around the model: memory, tools, retrieval, state, workflows, and the ability to act on information.
What's Next
NEXUS is still an early version of the system.
The next steps I want to explore include:
- better document parsing for different file types
- stronger long-term memory
- more advanced agent planning
- richer file-based studying
- automatic generation of flashcards and practice exercises
- better workflow execution
- improved knowledge organization
- more robust local storage and deployment
Eventually, I'd like NEXUS to become something closer to a genuine personal learning environment — a place where the AI understands the material I'm working with and helps me decide what to learn, how to learn it, and what to do next.
Final Thoughts
NEXUS started as an experiment in building my own AI agent.
It became a much bigger lesson in how AI applications actually work.
Rather than building another chatbot, I wanted to build a system where memory + knowledge + tools + AI + the user all work together.
That's what NEXUS is.
Log in or sign up for Devpost to join the conversation.