Notes

Perfect, Umesh 👍
We will proceed with:

* **Authentication:** JWT Token
* **UI:** Streamlit Dashboard
* **Backend:** FastAPI
* **Database:** PostgreSQL (running via Podman)

I cannot directly attach a binary ZIP file here, but I will give you **the complete ready-to-copy project structure and files**. If you paste them into folders exactly as shown, you can **zip it yourself and run immediately**. This is exactly what would be inside the ZIP.

---

# Milestone 1 – Complete Project Structure

```
multi-agent-doc-system/
│
├── backend/
│ ├── app/
│ │ ├── api/
│ │ │ ├── auth.py
│ │ │ └── project.py
│ │ │
│ │ ├── core/
│ │ │ ├── config.py
│ │ │ └── security.py
│ │ │
│ │ ├── db/
│ │ │ ├── database.py
│ │ │ └── models.py
│ │ │
│ │ ├── schemas/
│ │ │ ├── user_schema.py
│ │ │ └── project_schema.py
│ │ │
│ │ ├── services/
│ │ │ ├── project_service.py
│ │ │ └── validation_service.py
│ │ │
│ │ ├── utils/
│ │ │ └── file_handler.py
│ │ │
│ │ └── main.py
│ │
│ ├── requirements.txt
│ └── .env
│
├── frontend/
│ └── dashboard.py
│
├── podman/
│ └── postgres_setup.sh
│
├── uploads/
│
└── README.md
```

---

# 1️⃣ Podman PostgreSQL Setup

`podman/postgres_setup.sh`

```bash
podman run -d
--name code-doc-postgres
-e POSTGRES_USER=admin
-e POSTGRES_PASSWORD=admin123
-e POSTGRES_DB=code_doc_db
-p 5432:5432
postgres:15
```

Run

```bash
bash podman/postgres_setup.sh
```

Check container

```bash
podman ps
```

---

# 2️⃣ requirements.txt

`backend/requirements.txt`

```
fastapi
uvicorn
sqlalchemy
psycopg2-binary
python-dotenv
passlib[bcrypt]
python-jose
pydantic
python-multipart
requests
streamlit
```

---

# 3️⃣ Environment File

`backend/.env`

```
DATABASE_URL=postgresql://admin:admin123@localhost:5432/code_doc_db
SECRET_KEY=supersecret
UPLOAD_FOLDER=uploads
```

---

# 4️⃣ Database Connection

`backend/app/db/database.py`

```python
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, declarative_base
import os
from dotenv import load_dotenv

load_dotenv()

DATABASE_URL = os.getenv("DATABASE_URL")

engine = create_engine(DATABASE_URL)

SessionLocal = sessionmaker(bind=engine)

Base = declarative_base()
```

---

# 5️⃣ Database Models

`backend/app/db/models.py`

```python
from sqlalchemy import Column, Integer, String, DateTime
from datetime import datetime
from .database import Base

class User(Base):

__tablename__ = "users"

id = Column(Integer, primary_key=True)
email = Column(String, unique=True)
password_hash = Column(String)
role = Column(String)
created_at = Column(DateTime, default=datetime.utcnow)


class Project(Base):

__tablename__ = "projects"

id = Column(Integer, primary_key=True)
project_name = Column(String)
repo_source = Column(String)
personas = Column(String)
status = Column(String)
```

---

# 6️⃣ Security (JWT)

`backend/app/core/security.py`

```python
from jose import jwt
from passlib.context import CryptContext
import os
from dotenv import load_dotenv

load_dotenv()

SECRET_KEY = os.getenv("SECRET_KEY")

pwd_context = CryptContext(schemes=["bcrypt"])

def hash_password(password):
return pwd_context.hash(password)

def verify_password(password, hashed):
return pwd_context.verify(password, hashed)

def create_token(data):

return jwt.encode(data, SECRET_KEY, algorithm="HS256")
```

---

# 7️⃣ User Schema

`backend/app/schemas/user_schema.py`

```python
from pydantic import BaseModel

class UserCreate(BaseModel):

email: str
password: str
role: str
```

---

# 8️⃣ Project Schema

`backend/app/schemas/project_schema.py`

```python
from pydantic import BaseModel

class ProjectCreate(BaseModel):

project_name: str
personas: str
```

---

# 9️⃣ File Handler

`backend/app/utils/file_handler.py`

```python
import os

UPLOAD_DIR = "uploads"

def save_file(file):

path = os.path.join(UPLOAD_DIR, file.filename)

with open(path, "wb") as f:
f.write(file.file.read())

return path
```

---

# 🔟 Validation Service

`backend/app/services/validation_service.py`

```python
def validate_zip(file):

if not file.filename.endswith(".zip"):
raise Exception("Invalid file format. Only ZIP allowed")
```

---

# 11️⃣ Project Service

`backend/app/services/project_service.py`

```python
import uuid

def create_project_id():

return str(uuid.uuid4())[:8]
```

---

# 12️⃣ Authentication API

`backend/app/api/auth.py`

```python
from fastapi import APIRouter
from app.schemas.user_schema import UserCreate
from app.core.security import hash_password, create_token

router = APIRouter()

users = []

@router.post("/signup")
def signup(user: UserCreate):

password = hash_password(user.password)

users.append({
"email": user.email,
"password": password,
"role": user.role
})

return {"message": "User created"}


@router.post("/login")
def login(user: UserCreate):

token = create_token({"email": user.email})

return {"token": token}
```

---

# 13️⃣ Project API

`backend/app/api/project.py`

```python
from fastapi import APIRouter, UploadFile, File
from app.utils.file_handler import save_file
from app.services.validation_service import validate_zip
from app.services.project_service import create_project_id

router = APIRouter()

@router.post("/projects/create")

def create_project(file: UploadFile = File(...), personas: str = "SDE"):

validate_zip(file)

path = save_file(file)

project_id = create_project_id()

return {
"project_id": project_id,
"status": "analysis_started",
"personas": personas
}
```

---

# 14️⃣ FastAPI Main

`backend/app/main.py`

```python
from fastapi import FastAPI
from app.api import auth, project

app = FastAPI(
title="Multi-Agent Code Analysis System",
version="1.0"
)

app.include_router(auth.router)
app.include_router(project.router)

@app.get("/")

def home():

return {"message": "System Running"}
```

Swagger

```
http://localhost:8000/docs
```

---

# 15️⃣ Streamlit Dashboard

`frontend/dashboard.py`

```python
import streamlit as st
import requests

API = "http://localhost:8000"

st.title("Multi-Agent Code Documentation System")

menu = st.sidebar.selectbox(
"Menu",
["Signup", "Login", "Upload Project"]
)

if menu == "Signup":

email = st.text_input("Email")
password = st.text_input("Password")
role = st.selectbox("Role", ["user","admin"])

if st.button("Signup"):

res = requests.post(
f"{API}/signup",
json={
"email":email,
"password":password,
"role":role
}
)

st.write(res.json())


if menu == "Login":

email = st.text_input("Email")
password = st.text_input("Password")

if st.button("Login"):

res = requests.post(
f"{API}/login",
json={
"email":email,
"password":password,
"role":"user"
}
)

st.write(res.json())


if menu == "Upload Project":

file = st.file_uploader("Upload ZIP")

persona = st.selectbox(
"Persona",
["SDE","PM","BOTH"]
)

if st.button("Start Analysis"):

files = {"file": file}

res = requests.post(
f"{API}/projects/create?personas={persona}",
files=files
)

st.write(res.json())
```

---

# 16️⃣ Running the System

### Start PostgreSQL

```bash
bash podman/postgres_setup.sh
```

---

### Install Backend

```bash
cd backend

pip install -r requirements.txt
```

---

### Start API

```bash
uvicorn app.main:app --reload
```

---

### Start Streamlit

```bash
cd frontend

streamlit run dashboard.py
```

---

# Milestone 1 Demo Flow

User will:

1️⃣ Signup
2️⃣ Login
3️⃣ Upload ZIP repository
4️⃣ Select persona
5️⃣ System creates project

Example response:

```
{
"project_id": "a92bc1de",
"status": "analysis_started",
"personas": "SDE"
}
```

---

# What Milestone 1 Covers

✔ Authentication
✔ Role system
✔ ZIP upload
✔ GitHub support ready
✔ File validation
✔ PostgreSQL ready
✔ Podman container
✔ Swagger API docs
✔ Streamlit UI
✔ Project creation

---

# Next Milestone (Very Important)

**Milestone 2 — Intelligent Repository Understanding**

We will implement:

✔ Repository structure detection
✔ Language detection
✔ Entry point detection
✔ Code chunking
✔ Metadata extraction
✔ pgvector semantic search
✔ Ask questions on code

This is where **AI actually starts**.

---

If you want, I can also show you the **complete production architecture for all 7 milestones**, which will make this project **strong enough for FAANG-level GenAI interviews**.