Building a Source-Backed Nutrition Chatbot: RAG with FastAPI & Pinecone

mkdir nutritrag-project
cd nutritrag-project
python -m venv venv
source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
```Next, create a `requirements.txt` file with the necessary libraries.
```text
# requirements.txt
fastapi
uvicorn[standard]
pinecone-client
sentence-transformers
python-dotenv
langchain
langchain-openai

pip install -r requirements.txt

# .env
PINECONE_API_KEY="YOUR_PINECONE_API_KEY"
OPENAI_API_KEY="YOUR_OPENAI_API_KEY"

# ingest.py
import os
from dotenv import load_dotenv
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import DirectoryLoader
from langchain_community.embeddings import HuggingFaceEmbeddings
from pinecone import Pinecone, ServerlessSpec

# Load environment variables
load_dotenv()

PINECONE_API_KEY = os.getenv("PINECONE_API_KEY")
PINECONE_INDEX_NAME = "nutritrag"

def ingest_data():
    """Load, chunk, embed, and store documents in Pinecone."""
    # 1. Load documents from the data directory
    loader = DirectoryLoader('data/', glob="**/*.txt", show_progress=True)
    documents = loader.load()
    print(f"Loaded {len(documents)} documents.")

    # 2. Chunk documents into smaller pieces
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
    docs = text_splitter.split_documents(documents)
    print(f"Split into {len(docs)} chunks.")

    # 3. Create embeddings
    embeddings_model = HuggingFaceEmbeddings(
        model_name="sentence-transformers/all-MiniLM-L6-v2"
    )
    print("Embedding model loaded.")

    # 4. Initialize Pinecone and create index
    pc = Pinecone(api_key=PINECONE_API_KEY)

    if PINECONE_INDEX_NAME not in pc.list_indexes().names():
        pc.create_index(
            name=PINECONE_INDEX_NAME,
            dimension=384,  # Dimension for all-MiniLM-L6-v2
            metric='cosine',
            spec=ServerlessSpec(
                cloud='aws',
                region='us-east-1'
            )
        )
        print(f"Pinecone index '{PINECONE_INDEX_NAME}' created.")
    
    index = pc.Index(PINECONE_INDEX_NAME)

    # 5. Upsert embeddings to Pinecone in batches
    batch_size = 100
    for i in range(0, len(docs), batch_size):
        batch = docs[i:i+batch_size]
        ids = [f"doc_{i+j}" for j in range(len(batch))]
        texts = [doc.page_content for doc in batch]
        embeds = embeddings_model.embed_documents(texts)
        metadata = [doc.metadata for doc in batch]
        
        # Prepare vectors for upsert
        vectors_to_upsert = []
        for doc_id, embed, meta in zip(ids, embeds, metadata):
            vectors_to_upsert.append({
                "id": doc_id,
                "values": embed,
                "metadata": { "text": texts[ids.index(doc_id)], **meta }
            })
        
        index.upsert(vectors=vectors_to_upsert)
        print(f"Upserted batch {i//batch_size + 1}")

    print("Data ingestion complete.")

if __name__ == "__main__":
    ingest_data()```

### How it works
1.  **Loading**: We use `DirectoryLoader` from LangChain to load all `.txt` files from our `data` folder.
2.  **Chunking**: Large documents are broken down into smaller, semantically coherent chunks using `RecursiveCharacterTextSplitter`. This ensures that our embeddings are focused and relevant.
3.  **Embedding**: We use the `all-MiniLM-L6-v2` model from Sentence-Transformers, a popular choice for its balance of performance and size. It converts each text chunk into a 384-dimensional vector.
4.  **Storing**: We initialize the Pinecone client, create a new index if it doesn't exist, and then `upsert` (upload/update) our chunks' embeddings and metadata. Storing the original text in the metadata is crucial for the generation step.

To run this, simply execute the script from your terminal:
```bash
python ingest.py

# main.py
import os
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from dotenv import load_dotenv
from pinecone import Pinecone
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA
from langchain_pinecone import PineconeVectorStore

# Load environment variables
load_dotenv()

# Initialize API keys and settings
PINECONE_API_KEY = os.getenv("PINECONE_API_KEY")
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
PINECONE_INDEX_NAME = "nutritrag"

# Initialize FastAPI app
app = FastAPI(
    title="NutriRAG API",
    description="An API for asking nutritional questions backed by scientific articles.",
    version="1.0.0",
)

# Pydantic model for request body
class QueryRequest(BaseModel):
    question: str

# Initialize Embeddings and LLM
embeddings_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
llm = ChatOpenAI(api_key=OPENAI_API_KEY, model_name='gpt-3.5-turbo', temperature=0.0)

# Initialize Pinecone Vector Store
vectorstore = PineconeVectorStore.from_existing_index(
    index_name=PINECONE_INDEX_NAME, 
    embedding=embeddings_model
)

# Create the RetrievalQA chain
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(),
    return_source_documents=True
)

@app.post("/ask")
async def ask_question(request: QueryRequest):
    """
    Receives a nutritional question, retrieves relevant context from Pinecone,
    and generates an answer using an LLM.
    """
    if not request.question:
        raise HTTPException(status_code=400, detail="Question cannot be empty.")
    
    try:
        response = qa_chain.invoke({"query": request.question})
        
        answer = response.get("result", "No answer found.")
        source_documents = response.get("source_documents", [])
        
        sources = []
        if source_documents:
            sources = [
                {"source": doc.metadata.get("source", "Unknown"), "text": doc.page_content}
                for doc in source_documents
            ]

        return {"answer": answer, "sources": sources}

    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/")
def read_root():
    return {"message": "Welcome to the NutriRAG API. Use the /docs endpoint to test."}

uvicorn main:app --reload```
Uvicorn will start a local server, usually on `http://127.0.0.1:8000`.

### Testing the API
FastAPI provides automatic interactive documentation. Open your browser and navigate to **`http://127.0.0.1:8000/docs`**. You'll see a Swagger UI where you can test the `/ask` endpoint directly.

1.  Click on the `/ask` endpoint to expand it.
2.  Click "Try it out".
3.  In the request body, enter a question related to your documents, like:
    ```json
    {
      "question": "What is the impact of omega-3 fatty acids on cognitive function?"
    }