ProjectPilot

Persistent project memory storing bugs, incidents, decisions, solutions, and lessons in CockroachDB.
Semantic search across project memories using CockroachDB’s distributed vector index.
ProjectPilot architecture connecting the frontend, FastAPI backend, AI agent, Amazon Bedrock, and CockroachDB Cloud.
AI Agent interface for answering engineering questions using project-specific memory and context.
ProjectPilot dashboard showing recent project activity and persistent project context powered by CockroachDB.

Inspiration

Engineering teams solve problems every day, but the knowledge created from those solutions is often lost in issue trackers, documents, chat messages, or simply in the memory of individual developers.

We wanted to build an AI assistant that doesn't just answer questions using general knowledge, but can remember what happened in a specific project and use that experience when helping developers in the future.

That idea led to ProjectPilot — an AI-powered project memory for engineering teams.

What it does

ProjectPilot allows teams to store project-specific engineering knowledge such as:

Bugs and their solutions
Production incidents
Technical decisions
Performance issues
Lessons learned

When a developer asks the AI a question, ProjectPilot determines whether the project's history is relevant. If it is, the system retrieves related memories using semantic search and provides them to the AI as context.

For example, if a previous incident involved a slow users API caused by a missing database index, a developer can later ask:

"Our users API is suddenly very slow. What should I investigate?"

Even though the wording is different, ProjectPilot can retrieve the previous incident and use it to ground the response.

How we built it

The application uses FastAPI as the backend and serves a lightweight HTML, CSS, and JavaScript frontend.

Project memories are stored in CockroachDB Cloud. Each memory is converted into a vector embedding, allowing ProjectPilot to perform semantic similarity search rather than relying only on exact keyword matches.

For the AI layer, we use Amazon Bedrock:

Amazon Titan Embeddings converts project memories and user questions into embeddings.
Claude uses the retrieved project context together with the user's question to generate the final response.

We also integrated CockroachDB Managed MCP tools, allowing the agent to interact with the database through the Model Context Protocol.

The overall flow is:

User Question → Agent Orchestrator → Embedding → Semantic Search → Relevant Project Memories → Claude → Grounded Response

ProjectPilot also exposes an Agent Activity trace and Memories Used section so developers can see what project knowledge influenced the response.

Challenges we ran into

One of the main challenges was making project memory useful without overwhelming the AI with irrelevant information.

We needed to distinguish between a general engineering question and a question where the project's history could provide valuable context. Semantic retrieval helped us solve this by finding memories based on meaning rather than exact wording.

Another challenge was integrating persistent vector-based memory with an agent workflow. Using CockroachDB for both structured project data and vector search allowed us to keep the memory layer in one place while also integrating database access through MCP.

Accomplishments that we're proud of

Building ProjectPilot showed us that useful AI applications are not only about generating better answers — they are also about giving AI the right context at the right time.

We learned how vector embeddings can turn unstructured engineering knowledge into searchable memory, how retrieval can ground LLM responses, and how MCP can connect agents with external tools and data sources.

What we learned

What's next for ProjectPilot

We envision ProjectPilot evolving into a continuous engineering knowledge layer that can automatically learn from issue trackers, incident reports, pull requests, and team documentation.

Future versions could provide proactive recommendations, automatically detect recurring problems, and surface relevant historical context while developers are working.

Our goal is simple:

Turn every solved problem into context for the next one.