Implement Milestone 6 by adding audit persistence functionality. Introduce `aiosqlite` as a dependency, update the audit routes to support event logging and retrieval, and enhance the query endpoint to persist audit records. Modify response models to include audit details and ensure proper initialization of the audit database on startup.

LOGICAL_DEVELOPMENT_SEQUENCE.md

@@ -0,0 +1,506 @@
+# DocuAudit AI - Milestone Development Sequence (Build -> Verify -> Move On)
+
+This guide is written so you can develop strictly milestone-by-milestone and validate your output at each step.
+
+Rule for progression:
+- If a milestone verification fails, do not continue to the next milestone.
+- Only move forward when all checks for the current milestone pass.
+
+---
+
+## Shared Setup and Run Commands
+
+### One-time setup
+```bash
+uv venv --python 3.11
+uv init --python 3.11
+uv pip install -r requirements.txt
+copy .env.example .env
+```
+
+### Run backend
+```bash
+uv run uvicorn api.main:app --host 0.0.0.0 --port 8000 --reload
+```
+
+### Run UI
+```bash
+uv run streamlit run streamlit_app.py
+```
+
+### Smoke checks
+```bash
+curl http://localhost:8000/health
+curl http://localhost:8000/docs
+```
+
+---
+
+## Milestone 1 - FastAPI Foundation
+
+### Dependencies 
+- `fastapi`
+- `uvicorn[standard]`
+
+### After adding dependencies 
+- `uv add requirements.txt`
+- `uv pip install -r requirements.txt`
+
+### Depends on previous milestones
+- None (starting point).
+
+### Expected input
+- Fresh repo with Python environment ready.
+- `requirements.txt` and `.env` prepared.
+
+### Build scope
+- Create `api/main.py`.
+- Add `GET /health`.
+- App starts with Uvicorn.
+
+### Expected output/result
+- API starts without errors.
+- `/health` returns success JSON.
+- Swagger loads at `/docs`.
+
+### Start backend server- fastapi
+  - `uv run uvicorn api.main:app --host 0.0.0.0 --port 8000 --reload`
+
+### Verification checks
+```bash
+curl http://localhost:8000/health
+curl http://localhost:8000/docs
+```
+
+### Pass criteria
+- No startup exception.
+- No 404/500 for `/health` and `/docs`.
+
+---
+
+## Milestone 2 - Route Skeletons (Placeholder Only)
+
+### Dependencies 
+- Milestone 1 dependencies only.
+- (No new runtime dependency required if routes are placeholders.)
+
+### Depends on previous milestones
+- Milestone 1 must pass (`/health` and `/docs` working).
+
+### Expected input
+- Running FastAPI app from Milestone 1.
+- Router module structure available under `api/routes`.
+
+### Build scope
+- Add routers:
+  - `api/routes/ingest.py`
+  - `api/routes/query.py`
+  - `api/routes/jobs.py`
+  - `api/routes/audit.py`
+- Register routes in `api/main.py`.
+- Keep responses as placeholders only.
+
+### Expected output/result
+- All route paths exist and respond.
+- Placeholder payloads return consistently.
+
+### Start backend server- fastapi
+  - `uv run uvicorn api.main:app --host 0.0.0.0 --port 8000 --reload`
+
+### Verification checks
+- Open Swagger and call each endpoint once.
+- Confirm no 404/500.
+
+### Pass criteria
+- Route wiring complete.
+- No real business logic yet.
+
+---
+
+## Milestone 3 - Config + Request/Response Contracts
+
+### Dependencies 
+- `pydantic`
+- `pydantic-settings`
+- `python-dotenv`
+
+### After adding dependencies 
+- `uv add requirements.txt`
+- `uv pip install -r requirements.txt`
+
+### Depends on previous milestones
+- Milestone 2 route skeletons must be wired and reachable.
+
+### Expected input
+- Existing route handlers ready for request body integration.
+- `.env` file available for settings values.
+
+### Build scope
+- Add `api/config.py` (env-backed settings).
+- Add `models/requests.py` and `models/responses.py`.
+- Apply request validation in routes.
+
+### Expected output/result
+- Config values read from `.env`.
+- Valid requests succeed.
+- Invalid payloads show schema errors.
+
+### Start backend server- fastapi
+  - `uv run uvicorn api.main:app --host 0.0.0.0 --port 8000 --reload`
+
+### Verification checks
+```bash
+curl -X POST http://localhost:8000/query/ask ^
+  -H "Content-Type: application/json" ^
+  -d "{\"question\":\"What are key risks?\",\"collection_name\":\"default\"}"
+```
+- Also test one invalid payload (e.g., missing `question`).
+
+### Pass criteria
+- Validation behavior is visible and correct.
+
+---
+
+## Milestone 4 - RAG Ingestion Pipeline (No Answer Generation)
+
+### Dependencies
+- `langchain`
+- `langchain-core` (pulled via LangChain ecosystem)
+- `langchain-chroma`
+- `chromadb`
+- `langchain-community`
+- `langchain-ollama` (if using Ollama embeddings)
+- `langchain-openai` + `openai` (if using OpenAI embeddings)
+- `pymupdf` (PDF loading)
+- `python-multipart` (file upload handling in ingest route)
+
+### After adding dependencies 
+- `uv add requirements.txt`
+- `uv pip install -r requirements.txt`
+
+### Depends on previous milestones
+- Milestone 3 contracts/config must pass.
+
+### Provider selection
+- Choose provider in `.env` via `LLM_PROVIDER`.
+- Supported values:
+  - `ollama`
+  - `openai`
+  - `anthropic`
+  - `huggingface`
+
+### Expected input
+- Valid upload route available to accept files.
+- Configuration values for chunking, Chroma path, and provider present.
+- Test documents (PDF/TXT/MD) ready for ingestion.
+
+### Build scope
+- Implement:
+  - `rag/loader.py`
+  - `rag/chunker.py`
+  - `rag/embedder.py`
+  - `rag/vector_store.py`
+- Wire ingest flow: load -> chunk -> embed -> persist.
+- Preserve metadata:
+  - `source`
+  - `page`
+  - `chunk_index`
+
+### Expected output/result
+- Upload/ingest creates vectors in Chroma.
+- Collection has stored documents/chunks.
+
+### Start backend server- fastapi
+  - `uv run uvicorn api.main:app --host 0.0.0.0 --port 8000 --reload`
+
+### Verification checks
+- Ingest sample PDF(s).
+- Confirm collection appears and has document count > 0.
+
+### Pass criteria
+- Vector persistence works.
+- No LLM answer quality evaluation yet (that is Milestone 5).
+
+---
+
+## Milestone 5 - Retrieval + Grounded LLM Answer
+
+### Dependencies
+- Keep Milestone 4 dependencies.
+- Add provider package(s) for your selected chat LLM:
+  - Ollama: `langchain-ollama`
+  - OpenAI: `langchain-openai`, `openai`
+  - Anthropic: `langchain-anthropic`, `anthropic`
+  - Hugging Face endpoint: `langchain-community` (+ API key)
+
+### After adding dependencies 
+- `uv add requirements.txt`
+- `uv pip install -r requirements.txt`
+
+### Depends on previous milestones
+- Milestone 4 vectors must exist in Chroma (ingestion verified).
+
+### Expected input
+- Ingested collection with non-zero document/chunk vectors.
+- Query endpoint contract from Milestone 3.
+- Valid LLM API key/local model access based on selected provider.
+
+### Build scope
+- Implement `rag/retriever.py` to:
+  - retrieve top-k chunks
+  - format context
+  - invoke configured LLM
+  - return answer + sources
+- Wire query routes to retriever.
+
+### Expected output/result
+- Query returns grounded answer based on retrieved chunks.
+- Source citations are included.
+- Empty/no-match returns safe fallback answer.
+
+### Start backend server- fastapi
+  - `uv run uvicorn api.main:app --host 0.0.0.0 --port 8000 --reload`
+
+### Verification checks
+- Ask question that is clearly answerable from uploaded docs.
+- Ask question not present in docs and verify fallback message.
+
+### Pass criteria
+- Retrieve-then-generate flow works reliably.
+
+---
+
+## Milestone 6 - Audit Persistence
+
+### Dependencies
+- `aiosqlite`
+
+### After adding dependencies 
+- `uv add requirements.txt`
+- `uv pip install -r requirements.txt`
+
+### Depends on previous milestones
+- Milestone 5 query flow must return answers reliably.
+
+### Expected input
+- Query route already producing response payload (`answer`, `sources`, metadata).
+- Writable SQLite path configured in environment.
+
+### Build scope
+- Implement `storage/audit_store.py` fully.
+- Persist query request/response metadata.
+- Add audit list/detail retrieval endpoints.
+
+### Expected output/result
+- Every query creates an audit record.
+- You can fetch log entries by list and id.
+
+### Start backend server- fastapi
+  - `uv run uvicorn api.main:app --host 0.0.0.0 --port 8000 --reload`
+
+### Verification checks
+- Run one query.
+- Fetch corresponding audit entry.
+
+### Pass criteria
+- Audit trail is complete and query-linked.
+
+---
+
+## Milestone 7 - Background Ingestion Jobs
+
+
+### Dependencies
+- No mandatory new package (uses FastAPI background tasks + existing modules).
+
+### After adding dependencies (if any)
+- `uv add requirements.txt`
+- `uv pip install -r requirements.txt`
+
+### Depends on previous milestones
+- Milestone 4 ingestion logic must work synchronously first.
+- Milestone 6 persistence layer should be available for job tracking.
+
+### Expected input
+- Working ingest function (`load -> chunk -> add_documents`).
+- Job status storage schema and endpoints available.
+
+### Build scope
+- Implement `workers/ingest_worker.py`.
+- Move ingestion processing to background.
+- Track status in jobs endpoints/store.
+
+### Expected output/result
+- Upload returns `job_id`.
+- Status transitions:
+  - `queued`
+  - `processing`
+  - `completed` or `failed`
+
+### Start backend server- fastapi
+  - `uv run uvicorn api.main:app --host 0.0.0.0 --port 8000 --reload`
+
+### Verification checks
+- Upload docs and poll job status endpoint.
+
+### Pass criteria
+- API remains responsive while ingestion runs.
+
+---
+
+## Milestone 8 - Endpoint Completion (Production Shape)
+
+### Dependencies
+- `httpx` (URL ingestion/download flow)
+
+### After adding dependencies 
+- `uv add requirements.txt`
+- `uv pip install -r requirements.txt`
+
+### Depends on previous milestones
+- Milestones 1 through 7 should be passing individually.
+
+### Expected input
+- Stable ingestion, retrieval, audit, and jobs internals.
+- Final request/response models already defined.
+
+### Build scope
+- Ensure behavior and contracts are complete for:
+  - `POST /ingest/upload`
+  - `POST /ingest/url`
+  - `GET /ingest/collections`
+  - `DELETE /ingest/collection/{collection_name}`
+  - `POST /query/ask`
+  - `POST /query/summarise`
+  - `GET /jobs`
+  - `GET /jobs/{job_id}`
+  - `GET /audit/logs`
+  - `GET /audit/logs/{query_id}`
+
+### Expected output/result
+- Full backend flow works from upload to audited answer.
+
+### Start backend server
+  - `uv run uvicorn api.main:app --host 0.0.0.0 --port 8000 --reload`
+
+### Verification checks
+- Run one complete cycle using API only:
+  - ingest -> job complete -> ask -> inspect sources -> fetch audit
+
+### Pass criteria
+- No contract mismatches or broken endpoints.
+
+---
+
+## Milestone 9 - Streamlit UI Integration
+
+### Dependencies
+- `streamlit`
+
+### After adding dependencies 
+- `uv add requirements.txt`
+- `uv pip install -r requirements.txt`
+
+### Depends on previous milestones
+- Milestone 8 full backend flow must be stable.
+
+### Expected input
+- Running backend server with all finalized endpoints.
+- Predictable API payload shapes for upload/query/jobs/audit.
+
+### Build scope
+- Connect `streamlit_app.py` to backend API.
+- Include Upload, Jobs, Ask, Summarise, Audit sections.
+
+### Expected output/result
+- Full flow works from UI alone.
+
+### Start backend server- fastapi
+```bash
+uv run uvicorn api.main:app --host 0.0.0.0 --port 8000
+```
+### Start frontend server- Streamlit
+```bash
+uv run streamlit run streamlit_app.py --server.address=0.0.0.0 --server.port=8501
+```
+
+### Verification checks
+- Perform end-to-end cycle from Streamlit without manual curl.
+
+### Pass criteria
+- UI reflects backend status and responses correctly.
+
+---
+
+## Milestone 10 - Tests and Hardening
+
+### Dependencies
+- `pytest`
+- `pytest-asyncio`
+
+### After adding dependencies 
+- `uv add requirements.txt`
+- `uv pip install -r requirements.txt`
+
+### Depends on previous milestones
+- Milestones 1 through 9 completed and stable enough to test.
+
+### Expected input
+- Final endpoint behavior and contracts.
+- Representative sample docs/test data and deterministic test cases.
+
+### Build scope
+- Add/update:
+  - `tests/test_ingest.py`
+  - `tests/test_query.py`
+  - `tests/test_audit.py`
+- Cover success + validation + failure paths.
+
+### Expected output/result
+- Automated tests pass and catch regressions.
+
+### Verification checks
+```bash
+uv run pytest -q
+uv run pytest tests/test_ingest.py -q
+uv run pytest tests/test_query.py -q
+uv run pytest tests/test_audit.py -q
+```
+
+### Pass criteria
+- Core behavior is test-covered and stable.
+
+---
+
+## Milestone-by-Milestone Output Checklist
+
+Use this quick gate before advancing:
+
+1. Milestone 1: API up + `/health` + `/docs`
+2. Milestone 2: all route stubs reachable
+3. Milestone 3: schema validation enforced
+4. Milestone 4: vectors written to Chroma
+5. Milestone 5: grounded answer + citations
+6. Milestone 6: audit log persisted and fetchable
+7. Milestone 7: background job lifecycle visible
+8. Milestone 8: full API flow complete
+9. Milestone 9: full UI flow complete
+10. Milestone 10: tests passing
+
+If any line fails, fix that milestone before moving forward.
+
+---
+
+## Development Completion Dependency Chain
+
+Use this chain to understand what must be complete before a later milestone is considered valid:
+
+- Milestone 2 depends on 1
+- Milestone 3 depends on 2
+- Milestone 4 depends on 3
+- Milestone 5 depends on 4
+- Milestone 6 depends on 5
+- Milestone 7 depends on 4 and 6
+- Milestone 8 depends on 1-7
+- Milestone 9 depends on 8
+- Milestone 10 depends on 1-9

README.md

@@ -34,4 +34,9 @@ uv run uvicorn api.main:app --host 0.0.0.0 --port 8000
 ### Start frontend server- Streamlit
 ```bash
 uv run streamlit run streamlit_app.py --server.address=0.0.0.0 --server.port=8501
-```
+```
+
+git diff --name-status --diff-filter=AM <from_commit_hash> <to_commit_hash>
+
+git diff --name-status --diff-filter=AM  18ad0e6c94d041b1fd902e7f9b60113738eee1fa 0f2ee3afa124348adece82df0ff0e5a0943a7b8b
+

api/main.py

@@ -1,4 +1,7 @@
 from fastapi import FastAPI
+
+from api.config import get_settings
+from storage.audit_store import init_audit_db
 from .routes import audit, ingest, jobs, query
 
 app = FastAPI()
@@ -8,6 +11,12 @@ app.include_router(ingest.router)
 app.include_router(jobs.router)
 app.include_router(query.router)
 
+
+@app.on_event("startup")
+async def startup() -> None:
+    settings = get_settings()
+    await init_audit_db(settings.audit_db_path)
+
 @app.get("/health", tags=["Health"])
 def health() -> dict[str, str]:
     return {"status": "ok","app_name": "doc-audi-ai", "version": "0.1.0"}

api/routes/audit.py

@@ -1,8 +1,11 @@
 from typing import Annotated
-from fastapi import APIRouter, Depends, Query
 
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+
+from api.config import get_settings
 from models.requests import AuditListParams
-from models.responses import AuditListResponse
+from models.responses import AuditDetailResponse, AuditEvent, AuditListResponse
+from storage.audit_store import get_audit_event, list_audit_events
 
 def _audit_list_params(
     limit: Annotated[int, Query(ge=1, le=100)] = 10,
@@ -12,12 +15,28 @@ def _audit_list_params(
 
 router = APIRouter(tags=["audit"])
 
-@router.get("/audit", response_model=AuditListResponse  )
-def audit_placeholder(
+@router.get("/audit", response_model=AuditListResponse)
+async def audit_list(
     params: Annotated[AuditListParams, Depends(_audit_list_params)],
 ) -> AuditListResponse:
+    settings = get_settings()
+    rows = await list_audit_events(settings.audit_db_path, limit=params.limit, offset=params.offset)
+    events = [AuditEvent.model_validate(row) for row in rows]
     return AuditListResponse(
-        status="placeholder",
-        message="Audit not implemented yet.",
-        events=[],
+        status="success",
+        message=f"Returned {len(events)} audit event(s).",
+        events=events,
+    )
+
+
+@router.get("/audit/{event_id}", response_model=AuditDetailResponse)
+async def audit_detail(event_id: str) -> AuditDetailResponse:
+    settings = get_settings()
+    event = await get_audit_event(settings.audit_db_path, event_id)
+    if event is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Audit event not found.")
+    return AuditDetailResponse(
+        status="success",
+        message="Audit event retrieved.",
+        event=event,
     )

api/routes/query.py

@@ -6,12 +6,13 @@ from models.responses import QueryResponse, QueryResultItem, QuerySourceItem
 from rag.embedder import create_embedding_function
 from rag.retriever import answer_with_grounding, retrieve_chunks
 from rag.vector_store import get_vector_store
+from storage.audit_store import persist_query_audit
 
 router = APIRouter(tags=["query"])
 
 
 @router.post("/query", response_model=QueryResponse)
-def query_endpoint(payload: QueryRequest) -> QueryResponse:
+async def query_endpoint(payload: QueryRequest) -> QueryResponse:
     settings = get_settings()
     try:
         embedding_function = create_embedding_function()
@@ -36,10 +37,20 @@ def query_endpoint(payload: QueryRequest) -> QueryResponse:
         )
         for chunk in chunks
     ]
-    return QueryResponse(
+    response = QueryResponse(
         status="success",
         message=f"Retrieved {len(results)} chunks from '{payload.collection_name}' and generated grounded answer.",
         answer=answer,
         sources=sources,
         results=results,
-    )
+    )
+    try:
+        await persist_query_audit(
+            settings.audit_db_path,
+            question=payload.question,
+            collection_name=payload.collection_name,
+            response=response,
+        )
+    except Exception as exc:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(exc)) from exc
+    return response

models/responses.py

@@ -36,8 +36,30 @@ class JobListResponse(BaseModel):
 class AuditEvent(BaseModel):
     event_id: str
     action: str
+    question: str | None = None
+    collection_name: str | None = None
+    created_at: str | None = None
 
 class AuditListResponse(BaseModel):
     status: str
     message: str
     events: list[AuditEvent] = Field(default_factory=list)
+
+
+class AuditDetail(BaseModel):
+    event_id: str
+    action: str
+    question: str
+    collection_name: str
+    answer: str | None = None
+    status: str
+    message: str
+    sources: list[QuerySourceItem] = Field(default_factory=list)
+    results: list[QueryResultItem] = Field(default_factory=list)
+    created_at: str
+
+
+class AuditDetailResponse(BaseModel):
+    status: str
+    message: str
+    event: AuditDetail | None = None

pyproject.toml

@@ -19,6 +19,7 @@ dependencies = [
     "pydantic-settings==2.3.4",
     "pymupdf==1.24.3",
     "python-multipart==0.0.9",
+    "aiosqlite>=0.21.0",
     "uvicorn[standard]==0.29.0",
     "huggingface-hub>=1.13.0",
     "langchain-huggingface>=0.0.3",

requirements.txt

@@ -13,5 +13,6 @@ openai==1.30.1
 anthropic==0.28.1
 pymupdf==1.24.3
 python-multipart==0.0.9
+aiosqlite
 huggingface-hub 
 langchain-huggingface

storage/__init__.py

@@ -0,0 +1 @@
+

storage/audit_store.py

@@ -0,0 +1,102 @@
+import json
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+import aiosqlite
+
+from models.responses import AuditDetail, QueryResponse
+
+
+async def init_audit_db(db_path: str) -> None:
+    db_file = Path(db_path)
+    db_file.parent.mkdir(parents=True, exist_ok=True)
+    async with aiosqlite.connect(db_file.as_posix()) as conn:
+        await conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS audit_events (
+                event_id TEXT PRIMARY KEY,
+                action TEXT NOT NULL,
+                question TEXT NOT NULL,
+                collection_name TEXT NOT NULL,
+                answer TEXT,
+                status TEXT NOT NULL,
+                message TEXT NOT NULL,
+                sources_json TEXT NOT NULL,
+                results_json TEXT NOT NULL,
+                created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+        await conn.commit()
+
+
+async def persist_query_audit(
+    db_path: str,
+    *,
+    question: str,
+    collection_name: str,
+    response: QueryResponse,
+) -> str:
+    event_id = str(uuid4())
+    await init_audit_db(db_path)
+    async with aiosqlite.connect(db_path) as conn:
+        await conn.execute(
+            """
+            INSERT INTO audit_events (
+                event_id, action, question, collection_name, answer, status, message, sources_json, results_json
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                event_id,
+                "query",
+                question,
+                collection_name,
+                response.answer,
+                response.status,
+                response.message,
+                json.dumps([item.model_dump() for item in response.sources]),
+                json.dumps([item.model_dump() for item in response.results]),
+            ),
+        )
+        await conn.commit()
+    return event_id
+
+
+async def list_audit_events(db_path: str, *, limit: int, offset: int) -> list[dict[str, Any]]:
+    await init_audit_db(db_path)
+    async with aiosqlite.connect(db_path) as conn:
+        conn.row_factory = aiosqlite.Row
+        cursor = await conn.execute(
+            """
+            SELECT event_id, action, question, collection_name, created_at
+            FROM audit_events
+            ORDER BY datetime(created_at) DESC, rowid DESC
+            LIMIT ? OFFSET ?
+            """,
+            (limit, offset),
+        )
+        rows = await cursor.fetchall()
+    return [dict(row) for row in rows]
+
+
+async def get_audit_event(db_path: str, event_id: str) -> AuditDetail | None:
+    await init_audit_db(db_path)
+    async with aiosqlite.connect(db_path) as conn:
+        conn.row_factory = aiosqlite.Row
+        cursor = await conn.execute(
+            """
+            SELECT event_id, action, question, collection_name, answer, status, message, sources_json, results_json, created_at
+            FROM audit_events
+            WHERE event_id = ?
+            """,
+            (event_id,),
+        )
+        row = await cursor.fetchone()
+    if row is None:
+        return None
+
+    payload = dict(row)
+    payload["sources"] = json.loads(payload.pop("sources_json") or "[]")
+    payload["results"] = json.loads(payload.pop("results_json") or "[]")
+    return AuditDetail.model_validate(payload)

uv.lock

@@ -133,6 +133,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
 ]
 
+[[package]]
+name = "aiosqlite"
+version = "0.22.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/8a/64761f4005f17809769d23e518d915db74e6310474e733e3593cfc854ef1/aiosqlite-0.22.1.tar.gz", hash = "sha256:043e0bd78d32888c0a9ca90fc788b38796843360c855a7262a532813133a0650", size = 14821, upload-time = "2025-12-23T19:25:43.997Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/b7/e3bf5133d697a08128598c8d0abc5e16377b51465a33756de24fa7dee953/aiosqlite-0.22.1-py3-none-any.whl", hash = "sha256:21c002eb13823fad740196c5a2e9d8e62f6243bd9e7e4a1f87fb5e44ecb4fceb", size = 17405, upload-time = "2025-12-23T19:25:42.139Z" },
+]
+
 [[package]]
 name = "annotated-doc"
 version = "0.0.4"
@@ -524,6 +533,7 @@ name = "doc-audi-ai"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
+    { name = "aiosqlite" },
     { name = "anthropic" },
     { name = "chromadb" },
     { name = "fastapi" },
@@ -547,6 +557,7 @@ dependencies = [
 
 [package.metadata]
 requires-dist = [
+    { name = "aiosqlite", specifier = ">=0.21.0" },
     { name = "anthropic", specifier = "==0.28.1" },
     { name = "chromadb", specifier = "==0.5.0" },
     { name = "fastapi", specifier = "==0.111.0" },