Manifest Recipes – AI-Powered Repository Intelligence & POS System
Project Overview
Manifest Recipes is a Django-based Point of Sale (POS) application designed to simplify restaurant transaction management. The application provides a centralized dashboard for managing products and monitoring financial transactions, with Razorpay payment gateway integration for processing and tracking payments.
The project is implemented using Python, Django, HTML, CSS, JavaScript, AJAX, Bootstrap, Razorpay, and dotenv. It also includes access control with different user roles for managing application functionality.
As an extension to the application, the repository can be integrated with an AI-powered Repository Intelligence platform that allows developers to connect a GitHub repository and interact with its codebase using natural language. Instead of manually navigating through multiple source files and documentation, users can ask questions about the architecture, business logic, APIs, dependencies, and implementation details.
Problem Statement
Understanding an unfamiliar codebase can be time-consuming for developers, especially when the repository contains multiple modules, configuration files, documentation, dependencies, and interconnected business logic.
Traditional approaches require developers to:
- Manually search through source files.
- Understand project structure before asking questions.
- Locate relevant documentation.
- Trace dependencies between modules.
- Identify where specific business logic is implemented.
- Switch between multiple files to understand a feature.
The proposed solution provides an AI-powered repository assistant that automatically ingests a GitHub repository, understands its code and documentation, and provides context-aware answers with references to the original source files.
AI Repository Intelligence Architecture
The overall workflow is:
User connects repository ↓ Repository ingestion worker ↓ Parse source code + documentation ↓ Generate embeddings + knowledge graph ↓ Store information in vector database ↓ User asks a natural-language question ↓ AI Agent analyzes the question ↓ Agent decides whether to search code, documentation, inspect files, or traverse relationships ↓ Relevant context is retrieved ↓ LLM generates the answer ↓ Answer is returned with source references
1. Repository Connection
The user connects a GitHub repository to the platform.
The system retrieves the repository structure, source files, configuration files, README/documentation, dependency information, and other relevant metadata.
For example, the Manifest Recipes repository contains Django/Python application code along with project configuration, README documentation, dependency files such as Pipfile and Pipfile.lock, and licensing information.
2. Repository Ingestion Worker
A background ingestion worker processes the repository asynchronously.
The worker:
- Clones or fetches the repository.
- Traverses the directory structure.
- Identifies supported file types.
- Filters unnecessary files such as build artifacts and binaries.
- Extracts source code and documentation.
- Tracks file paths and repository metadata.
- Creates a versioned representation of the repository.
A worker-based architecture prevents large repositories from blocking the main API request and allows ingestion to run asynchronously.
Example technologies:
- Python
- Celery
- Redis
- GitHub API
- Background workers
3. Code & Documentation Parsing
The ingestion pipeline parses different types of repository content.
For source code, parsing can extract:
- Classes
- Functions
- Methods
- Imports
- Variables
- API endpoints
- Models
- Relationships
- Dependencies
- Configuration
For documentation, the system processes:
- README files
- Markdown documentation
- API documentation
- Configuration descriptions
- Comments and docstrings
For the Manifest Recipes application, this allows the AI system to understand concepts such as Django application structure, payment processing through Razorpay, user access control, and transaction management.
4. Embedding Generation
The extracted code and documentation are divided into meaningful chunks.
Each chunk is converted into a vector representation using an embedding model.
For example:
Source file
↓
Code parser
↓
Semantic chunks
↓
Embedding model
↓
Vector representation
The embedding captures the semantic meaning of the code rather than relying only on keyword matching.
This enables questions such as:
"Where is the payment transaction handled?"
to retrieve relevant code even when the exact words in the question do not appear in the source file.
5. Knowledge Graph Construction
In addition to vector search, the system can construct a knowledge graph representing relationships inside the repository.
Example:
PaymentView
|
├── calls → Razorpay API
|
├── uses → Payment Model
|
└── updates → Transaction Record
The graph can represent relationships such as:
- File → Class
- Class → Method
- Method → Function
- Function → Dependency
- API → View
- View → Model
- Model → Database
- Module → Module
This provides structural understanding that pure vector search may miss.
6. Vector Database
The generated embeddings are stored in a vector database together with metadata.
Example metadata:
{
"repository": "Manifest-Recipes",
"file": "payments/views.py",
"language": "Python",
"symbol": "process_payment",
"chunk_type": "function"
}
Possible technologies include:
- PostgreSQL + pgvector
- Pinecone
- Qdrant
- Weaviate
- Chroma
For a production implementation, PostgreSQL + pgvector is a strong option because relational metadata and vector search can be maintained within the same database.
Agentic Question Answering
Once the repository has been indexed, the user can ask questions using natural language.
Example:
"How does the application process restaurant payments?"
Instead of blindly performing a vector search, an AI Agent determines what information is required to answer the question.
Agent Decision Flow
User Question
↓
AI Agent
|
├── Search source code
|
├── Search documentation
|
├── Inspect specific files
|
├── Search dependencies
|
└── Traverse knowledge graph
↓
Retrieved Context
↓
LLM
↓
Answer + Source References
This makes the system agentic rather than a simple RAG chatbot.
Example Query
User:
"Where is Razorpay integrated and how does the payment flow work?"
Agent:
- Detects that the question is related to payment processing.
- Searches the code index for Razorpay-related symbols.
- Retrieves relevant Django views/functions.
- Searches documentation for payment-related information.
- Traverses the knowledge graph to identify dependencies.
- Inspects the relevant source files.
- Combines the retrieved context.
- Sends the context to the LLM.
Generated Response:
The AI explains the payment flow and provides references such as:
Payment flow:
User
↓
Django payment endpoint
↓
Razorpay integration
↓
Payment processing
↓
Transaction record
↓
Dashboard
The response also provides source references such as:
Source:
payments/views.py
Function: process_payment
This allows the developer to immediately navigate to the implementation instead of blindly trusting the AI-generated answer.
Source-Aware Responses
One of the key features of the system is source-grounded answers.
Instead of returning:
"The application uses Razorpay for payments."
the system can return:
"The application integrates Razorpay as the payment gateway. The payment-related implementation is located in the Django payment handling module."
followed by:
Sources:
• payments/views.py
• payments/models.py
• README.md
This improves:
- Accuracy
- Explainability
- Developer trust
- Debugging
- Code navigation
Technology Stack
Backend
- Python
- Django / Django REST Framework
- REST APIs
- Celery for asynchronous repository ingestion
- Redis as the task broker/cache
AI / GenAI
- LLM for reasoning and answer generation
- Embedding model for semantic search
- Retrieval-Augmented Generation (RAG)
- Agentic workflow for tool selection
- Knowledge graph for code relationships
Data Layer
- PostgreSQL
- pgvector for vector similarity search
- Knowledge graph / graph representation for repository relationships
Repository Integration
- GitHub API
- GitHub repository access
- Git-based repository ingestion
Frontend
- React / TypeScript
- Dashboard for repository management
- Chat interface for repository questions
- Source/file navigation
Existing Manifest Recipes Application
The original application uses:
- Python
- Django
- HTML
- CSS
- JavaScript
- AJAX
- Bootstrap
- Razorpay
- dotenv
Key Features
Repository Understanding
Automatically indexes source code, documentation, dependencies, and repository structure.
Semantic Code Search
Allows developers to search the codebase using natural language instead of exact keywords.
Agentic Retrieval
An AI Agent dynamically decides which tools to use based on the user's question.
Knowledge Graph
Captures relationships between files, classes, functions, APIs, models, and dependencies.
Source References
Every generated answer can provide references to the files and code sections used to generate the response.
Asynchronous Ingestion
Large repositories can be processed using background workers without blocking the application.
Incremental Indexing
Future versions can detect changed files and re-index only modified portions of a repository instead of processing the entire repository again.
Example Questions
Developers can ask:
- "How does the payment flow work?"
- "Where is Razorpay integrated?"
- "Which Django views handle transactions?"
- "What are the main models in this application?"
- "How does authentication work?"
- "Which files are responsible for user access control?"
- "Show me the dependency chain for the payment module."
- "Where should I modify the code to add a new payment method?"
- "Explain the architecture of this repository."
- "What happens when a user creates a transaction?"
The agent retrieves the relevant code and documentation before generating the answer.
Architecture Summary
┌─────────────────────┐
│ GitHub │
│ Repository │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Repository Ingestion│
│ Worker │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Code + Documentation│
│ Parser │
└──────────┬──────────┘
│
┌──────────┴──────────┐
▼ ▼
┌─────────────────┐ ┌─────────────────┐
│ Embeddings │ │ Knowledge Graph │
└────────┬────────┘ └────────┬────────┘
│ │
▼ ▼
┌─────────────────┐ ┌─────────────────┐
│ Vector Database │ │ Graph Storage │
└────────┬────────┘ └────────┬────────┘
│ │
└──────────┬──────────┘
▼
┌─────────────────────┐
│ AI Agent │
└──────────┬──────────┘
│
┌─────────────┼─────────────┐
▼ ▼ ▼
Code Search Docs Search File/Graph
Inspection
│ │ │
└─────────────┼─────────────┘
▼
┌─────────────────────┐
│ LLM │
│ Answer Generation │
└──────────┬──────────┘
▼
┌─────────────────────┐
│ Answer + Citations │
│ + Source References │
└─────────────────────┘
Project Impact
The project combines a traditional Django-based POS application with modern Generative AI, RAG, vector search, knowledge graphs, and agentic workflows.
The key innovation is moving from a simple chatbot that searches text to an AI repository engineer capable of deciding how to investigate a codebase, combining multiple sources of context, and producing explainable answers backed by actual repository files.
Built With
- agentic
- ai
- background
- database
- docker
- fastapi
- github
- mcp
- postgresql
- rag
- react
- redis
- typescript
- vector
- workers
- workflows
Log in or sign up for Devpost to join the conversation.