I am extending my Session 1 FastAPI /ask service for a Session 2 RAG assignment. Please read this repo and explain in plain English:
1. Where POST /ask is implemented
2. How structured output, tokens_used, and cost_usd are returned
3. Where I should add POST /ingest and vector-store logic
4. What env vars I will need for Pinecone (or ChromaDB) and OpenAI embeddings

Do not write code yet - just map the project.

Add Pinecone vector store support to this FastAPI project.

Requirements:
- Config via environment variables (no secrets in code)
- Use text-embedding-3-small for embeddings (same model at ingest and query time)
- Add a small health/debug function I can call to confirm Pinecone is reachable

Explain what env vars I must set locally and on Render.

Build POST /ingest on this FastAPI app.

Requirements:
- Accept JSON with text + document_id (and optional metadata like source filename)
- Chunk with RecursiveCharacterTextSplitter - chunk_size ~800, overlap ~100 (make these configurable)
- Embed each chunk with text-embedding-3-small
- Upsert into the vector store with metadata: document_id, chunk_index, source
- Return JSON: document_id, chunks_indexed, status

Include a curl example in comments. Handle empty input with a clear 400 error.

Before changing POST /ask, add GET /debug/retrieve?q=... (or a small script) that:
1. Embeds the question
2. Returns top-5 chunks with similarity scores and document_id metadata
3. Does NOT call the LLM

I will use this to verify retrieval before wiring generation.

Upgrade POST /ask to use retrieval-augmented generation:
1. Embed the question
2. Retrieve top-k chunks (start with k=5)
3. Build a grounding prompt: answer ONLY from context, cite document_id for each chunk used, refuse if context is insufficient
4. Call the existing Session 1 generation path
5. Preserve tokens_used and cost_usd in the response where possible
6. Include retrieved chunk IDs in the response JSON

Show me the grounding prompt template you used.

Help me ingest the Northwind sample docs via POST /ingest.
For each file: read text, assign a stable document_id, call ingest, print chunk count.
At the end, print total chunks in the vector store.

Help me prove the basic RAG submission.

Use my live URL and show:
1. One question that should be answered from the ingested docs, with cited document_id or chunk IDs
2. One question that is NOT in the docs and should trigger the refusal response
3. The curl commands and full JSON responses for both

Keep the explanation simple enough to paste into Maven.

I have a live FastAPI service with POST /ingest and POST /ask (RAG). Please build a minimal Streamlit UI that:
1. Lets me paste text + document_id and call /ingest
2. Lets me ask a question and call /ask
3. Shows citations / refusal clearly in the response
4. Points at my live Render URL via an env var or sidebar input (not hardcoded secrets)

Keep the API as the source of truth. Do not reimplement RAG inside Streamlit. Tell me the exact run command and what screenshot to take for Maven.

Help me create a golden-set eval for my RAG service with at least 5 questions I know the answers to.

For each question record:
- question
- expected answer (short)
- retrieval hit? (right chunk in top-5)
- faithfulness? (answer grounded in retrieved text)
- correctness? (matches expected)
- one question that SHOULD trigger refusal (answer not in docs)

Format as a markdown table I can paste into README.

I have completed the basic Session 2 RAG assignment (including Streamlit UI). Help me choose ONE add-on based on my current code and corpus:
1. Chunk size comparison
2. Hybrid search
3. Metadata filtering
4. Batch ingest
5. Reranking

Recommend the most useful one, explain why, then implement it in small steps with a simple before/after test.