Upload 12 files

.gitignore

@@ -0,0 +1,14 @@
+# Environment
+.env
+.venv/
+venv/
+__pycache__/
+*.pyc
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db

README.md

@@ -1,11 +1,228 @@
----
-title: Portfolio Backend
-emoji: 📚
-colorFrom: purple
-colorTo: yellow
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Portfolio Chatbot API
+
+A RAG (Retrieval-Augmented Generation) based chatbot API for Mrigank Singh's portfolio, powered by FastAPI, Google Gemini, and Pinecone.
+
+## 🚀 Features
+
+- **FastAPI Backend**: High-performance async API with automatic OpenAPI documentation
+- **RAG Architecture**: Combines semantic search with LLM generation for accurate, context-aware responses
+- **Vector Search**: Uses Pinecone for efficient similarity search over portfolio knowledge base
+- **Google Gemini Integration**: Leverages Gemini 2.0 Flash for responses and embedding generation
+- **CORS Enabled**: Ready for frontend integration from any origin
+- **Production Ready**: Deployed on Render with health check endpoints
+
+## 📋 Prerequisites
+
+- Python 3.9+
+- Pinecone account and API key
+- Google AI Studio API key
+- (Optional) Render account for deployment
+
+## 🛠️ Installation
+
+1. **Clone the repository**
+   ```bash
+   git clone <repository-url>
+   cd Portfolio-Backend
+   ```
+
+2. **Create a virtual environment**
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   ```
+
+3. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Set up environment variables**
+   
+   Create a `.env` file in the root directory:
+   ```env
+   GOOGLE_API_KEY=your_google_api_key_here
+   PINECONE_API_KEY=your_pinecone_api_key_here
+   ```
+
+## 📊 Project Structure
+
+```
+Portfolio-Backend/
+├── app/
+│   ├── __init__.py          # Application initialization
+│   ├── main.py              # FastAPI app and endpoints
+│   └── utils.py             # RAG pipeline and helper functions
+├── data/
+│   └── knowledge_base.txt   # Portfolio information source
+├── scripts/
+│   └── ingest.py            # Data ingestion script for Pinecone
+├── render.yaml              # Render deployment configuration
+├── requirements.txt         # Python dependencies
+└── README.md               # This file
+```
+
+## 🔧 Configuration
+
+### Pinecone Setup
+
+1. Create a Pinecone index named `portfolio-chat`
+2. Configure the index with:
+   - Dimension: 768 (matches Gemini embedding model)
+   - Metric: Cosine similarity
+
+### Knowledge Base
+
+The knowledge base is stored in [data/knowledge_base.txt](data/knowledge_base.txt). The file should contain information about the portfolio owner, structured in chunks separated by double newlines.
+
+## 📤 Data Ingestion
+
+Before running the API, you need to ingest the knowledge base into Pinecone:
+
+```bash
+python scripts/ingest.py
+```
+
+This script will:
+1. Load and chunk the knowledge base text file
+2. Generate embeddings using Google Gemini
+3. Upsert vectors to Pinecone in batches
+
+## 🚀 Running the Application
+
+### Development
+
+```bash
+uvicorn app.main:app --reload --host 0.0.0.0 --port 8000
+```
+
+The API will be available at `http://localhost:8000`
+
+### Production
+
+```bash
+uvicorn app.main:app --host 0.0.0.0 --port 10000
+```
+
+## 📡 API Endpoints
+
+### Health Check
+```http
+GET /
+```
+Returns the API status.
+
+**Response:**
+```json
+{
+  "status": "ok"
+}
+```
+
+### Chat
+```http
+POST /chat
+```
+
+Send a message to the chatbot and receive a context-aware response.
+
+**Request Body:**
+```json
+{
+  "message": "Tell me about Mrigank's projects"
+}
+```
+
+**Response:**
+```json
+{
+  "response": "Mrigank has worked on several impressive projects including..."
+}
+```
+
+**Error Responses:**
+- `400 Bad Request`: Empty message
+- `500 Internal Server Error`: Error generating response
+
+## 🧠 How RAG Works
+
+1. **Query Embedding**: User's question is converted to a 768-dimensional vector using Gemini
+2. **Semantic Search**: Top 5 most relevant chunks are retrieved from Pinecone
+3. **Context Assembly**: Retrieved chunks are combined into a context string
+4. **LLM Generation**: Context and query are sent to Gemini 2.0 Flash for response generation
+5. **Response**: Contextually accurate answer is returned to the user
+
+## 🌐 Deployment
+
+This project is configured for deployment on Render. The [render.yaml](render.yaml) file contains the deployment configuration.
+
+### Deploy to Render
+
+1. Connect your GitHub repository to Render
+2. Render will automatically detect the `render.yaml` configuration
+3. Add environment variables in Render dashboard:
+   - `GOOGLE_API_KEY`
+   - `PINECONE_API_KEY`
+4. Deploy!
+
+## 🔑 Environment Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| `GOOGLE_API_KEY` | Google AI Studio API key | Yes |
+| `PINECONE_API_KEY` | Pinecone API key | Yes |
+
+## 📦 Dependencies
+
+- **FastAPI** (0.115.0): Modern web framework for building APIs
+- **Uvicorn** (0.30.6): ASGI server for running FastAPI
+- **Google GenAI** (1.0.0): Google's generative AI client library
+- **Pinecone Client** (5.0.1): Vector database client
+- **Pydantic** (2.9.2): Data validation using Python type annotations
+- **Python-dotenv** (1.0.1): Environment variable management
+
+## 📝 API Documentation
+
+Once the server is running, visit:
+- Swagger UI: `http://localhost:8000/docs`
+- ReDoc: `http://localhost:8000/redoc`
+
+## 🛡️ Security Considerations
+
+- Store API keys securely in environment variables, never commit them to version control
+- In production, restrict CORS origins to trusted domains
+- Consider rate limiting for the `/chat` endpoint
+- Implement authentication for sensitive deployments
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+**Issue**: `PINECONE_API_KEY not found`
+- **Solution**: Ensure `.env` file exists and contains the required API keys
+
+**Issue**: `Index 'portfolio-chat' not found`
+- **Solution**: Create the Pinecone index before running the ingestion script
+
+**Issue**: `No context chunks found`
+- **Solution**: Run the ingestion script to populate the Pinecone index
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is part of a personal portfolio. All rights reserved.
+
+## 📧 Contact
+
+For questions or collaboration opportunities, reach out to Mrigank Singh through his portfolio website.
+
+---
+
+**Built with** ❤️ **using FastAPI, Google Gemini, and Pinecone**

app/__init__.py

@@ -0,0 +1,8 @@
+"""
+Portfolio Chatbot Backend
+
+A RAG-based chatbot API using FastAPI, Google Gemini, and Pinecone.
+"""
+
+__version__ = "1.0.0"
+__author__ = "Mrigank Singh"

app/main.py

@@ -0,0 +1,49 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+from app.utils import get_rag_response
+
+app = FastAPI(
+    title="Portfolio Chatbot API",
+    description="RAG-based chatbot for Mrigank Singh's portfolio",
+    version="1.0.0"
+)
+
+# CORS Middleware 
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["https://mrigank-portfolio-website.vercel.app", "https://mrigank-portfolio-website.vercel.app/"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+class ChatRequest(BaseModel):
+    message: str
+
+
+class ChatResponse(BaseModel):
+    response: str
+
+
+@app.get("/")
+async def health_check():
+    """Health check endpoint for Render."""
+    return {"status": "ok"}
+
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest):
+    """
+    Chat endpoint - processes user message through RAG pipeline.
+    """
+    if not request.message.strip():
+        raise HTTPException(status_code=400, detail="Message cannot be empty")
+    
+    try:
+        response = get_rag_response(request.message)
+        return ChatResponse(response=response)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating response: {str(e)}")

app/utils.py

@@ -0,0 +1,111 @@
+import os
+from dotenv import load_dotenv
+from google import genai
+from google.genai import types
+from pinecone import Pinecone
+
+load_dotenv()
+
+# Initialize Pinecone
+pc = Pinecone(api_key=os.getenv("PINECONE_API_KEY"))
+index = pc.Index("portfolio-chat")
+
+# Initialize Google GenAI Client
+client = genai.Client(api_key=os.getenv("GOOGLE_API_KEY"))
+
+# Constants
+EMBEDDING_MODEL = "gemini-embedding-001"
+LLM_MODEL = "gemini-2.5-flash-lite"
+EMBEDDING_DIMENSION = 768
+
+def get_embedding(text: str) -> list[float]:
+    """Generate embedding for a given text using Gemini embedding model."""
+    try:
+        response = client.models.embed_content(
+            model=EMBEDDING_MODEL,
+            contents=text,
+            config=types.EmbedContentConfig(
+                output_dimensionality=EMBEDDING_DIMENSION
+            )
+        )
+        return response.embeddings[0].values
+    except Exception as e:
+        print(f"Error generating embedding: {e}")
+        return []
+
+def get_rag_response(query: str) -> str:
+    """
+    RAG pipeline: embed query, retrieve context from Pinecone, generate response.
+    """
+    try:
+        # Step 1: Embed the query
+        query_embedding = get_embedding(query)
+        if not query_embedding:
+            return "I'm having a little trouble accessing my brain right now. Please try again!"
+
+        # Step 2: Query Pinecone for top 5 matches
+        results = index.query(
+            vector=query_embedding,
+            top_k=10,
+            include_metadata=True
+        )
+        
+        # Step 3: Extract context from matches
+        context_chunks = []
+        for match in results.matches:
+            if match.metadata and "text" in match.metadata:
+                context_chunks.append(match.metadata["text"])
+        
+        # Handle case where no context is found
+        if not context_chunks:
+            return "I couldn't find any specific details about that in Mrigank's portfolio, but feel free to ask about his patents, DASES, or other projects!"
+        
+        # Join chunks to create the context text
+        context_text = "\n\n---\n\n".join(context_chunks)
+        
+        # Step 4: Construct the system prompt
+        system_prompt = f"""You are the Advanced AI Assistant for **Mrigank Singh**, a Full Stack AI Developer and Innovator. 
+        Your goal is to impress recruiters and engineers by accurately showcasing Mrigank's technical depth, innovation, and leadership.
+
+        ### CORE INSTRUCTIONS:
+        1. **Identity:** You are NOT Mrigank. You are his digital assistant. Refer to him as "Mrigank" or "he".
+        2. **Tone:** Professional, confident, and technically precise. Sound like a Software Engineer, not a marketing brochure.
+        3. **Formatting:** Use **Markdown** to make answers readable. 
+           - Use **bold** for key technologies or metrics.
+           - Use `bullet points` for lists (skills, projects).
+           - Do not output large walls of text; break it up.
+        4. **Source of Truth:** Answer ONLY based on the "CONTEXT" provided below. Do not make up facts. 
+           - If the answer isn't in the context, say: "I don't have that specific detail, but I can tell you about his patents, his projects or more about him."
+
+        ### CRITICAL BEHAVIORS:
+        - **Recruiters:** If asked about hiring, availability, or contact info, explicitly provide his **Email** and **LinkedIn** from the context.
+        - **Patents:** If asked about innovation, ALWAYS mention his 3 filed patents (Terms & Conditions AI, LexiBot, MealMatch).
+        - **Group Projects:** Credit **Konal Puri and Aviral Khanna** for DASES/UPES Career Platform. Specify Mrigank's role (Mobile App/Frontend).
+        - **Technical Depth:** Mention specific algorithms (e.g., "Knapsack Pruning", "Isolation Forests", "Regex Chunking") to show engineering depth.
+
+        ### CONTEXT FROM KNOWLEDGE BASE:
+        {context_text}
+        """
+        
+        # Step 5: Generate response using Gemini
+        response = client.models.generate_content(
+            model=LLM_MODEL,
+            contents=[
+                types.Content(
+                    role="user", 
+                    parts=[
+                        types.Part.from_text(text=system_prompt + "\n\nUser Question: " + query)
+                    ]
+                )
+            ],
+            config=types.GenerateContentConfig(
+                temperature=0.7,
+                max_output_tokens=500
+            )
+        )
+        
+        return response.text
+
+    except Exception as e:
+        print(f"Error in RAG pipeline: {e}")
+        return "I'm encountering a temporary issue connecting to the knowledge base. Please try again in a moment."

data/knowledge_base.txt

@@ -0,0 +1,117 @@
+### PROJECT_MASTER_INDEX
+**Full Project List for Mrigank Singh:**
+
+**SOLO PROJECTS (Built Individually):**
+1. **MealMatch AI:** A serverless food ordering app using Knapsack algorithms for budget/calorie optimization.
+2. **JobFit:** An AI Agentic pipeline for resume-job matching using LangGraph and Gemini.
+3. **LexiBot:** A RAG-based legal assistant for Indian Law using Intelligent Chunking.
+4. **F&B Process Anomaly Detection:** An industrial ML pipeline using Isolation Forests and Autoencoders.
+5. **Better LinkedIn:** A frontend architectural redesign focusing on performance and UX.
+
+**GROUP PROJECTS (Collaborations):**
+1. **DASES (Descriptive Answer Sheet Evaluation System):** Built with mentors Konal Puri & Aviral Khanna. Mrigank built the Mobile App (React Native) and contributed to Web Frontend.
+2. **UPES Career Services Platform:** Built with Konal Puri & Aviral Khanna. Mrigank built the Frontend (React/Vite) and AI Prompts.
+
+**PATENTS (3 Filed):**
+1. AI-Assisted Terms & Conditions System.
+2. LexiBot (Legal Assistant).
+3. MealMatch AI (Food Optimization).
+
+### GENERAL_FAQ_AND_FACTS
+**Availability & Contact:**
+- **Status:** Actively seeking **Summer Internships for 2026**. Open to **Remote roles** (if compatible with college hours) and **Domestic Relocation**.
+- **Contact:** Email: `mriganksingh005@gmail.com` | Phone: `+91 82734 37398`
+- **Socials:** LinkedIn: `linkedin.com/in/mrigank005` | GitHub: `github.com/Mrigank005`
+- **Location:** Dehradun/Kanpur, India (Timezone: IST +5:30).
+- **Graduation:** May/June 2028.
+
+**Technical Snapshot:**
+- **Strongest Stack:** React (Frontend) + FastAPI (Backend) + Supabase (DB/Auth).
+- **Languages:** Python, JavaScript, TypeScript. (Uses C/C++ and Java for DSA).
+- **AI/ML:** Gemini API, LangChain, LangGraph, TensorFlow, PyTorch, RAG Pipelines.
+- **Databases:** PostgreSQL, MongoDB, Pinecone, Qdrant, Supabase.
+- **Tools:** Docker, Git, VS Code.
+
+**Current Focus:**
+- **Learning:** Mastering Advanced System Design, Agentic AI Workflows, and Open Source contributions.
+- **Certifications:** Currently pursuing Machine Learning Specialization on DeepLearning.AI.
+- **Hobbies:** Table Tennis, Cricket, Gaming (BGMI), and Music.
+
+### PROJECT_1_DEEP_DIVE: DASES (Flagship Project)
+**Full Name:** Descriptive Answer Sheet Evaluation System
+**Type:** Group Project (Teammates: Konal Puri, Aviral Khanna).
+**Mrigank's Role:** Built the **Mobile App** from scratch (React Native/Expo) and contributed to Web Frontend.
+**Status:** Mobile App is in final stages; Web App deployed at `dases.esun.solutions`.
+**Summary:** An AI-driven system using OCR and LLMs to grade handwritten descriptive answers 90x faster than manual methods with 98% accuracy.
+**Key Technical Features (Mobile App):**
+- **Locked Exam Mode:** Implemented a "High Security" environment. Uses `AppState` listeners to detect background switching. If a student leaves the app for >15s, the exam auto-submits.
+- **Secure Scanning:** Custom camera interface (VisionKit/LMS) that disables gallery uploads, forcing live capture to prevent cheating.
+- **Auth Persistence:** Built a custom `SecureStoreAdapter` to bridge Supabase Auth with the device's encrypted Keychain/Keystore, solving standard localStorage security risks on mobile.
+**Impact:** Reduced grading cost from ₹25/sheet (Cloud) to ₹2/sheet (In-house GPU).
+
+### PROJECT_2_DEEP_DIVE: LexiBot (AI Legal Assistant)
+**Type:** Solo Project (Patent Filed).
+**Deployed Link:** `lexibot-ai.vercel.app`
+**Summary:** A Telegram chatbot for Indian legal queries (Consumer, Traffic, Harassment law) using RAG.
+**Technical "Flex":**
+- **Intelligent Chunking:** Does NOT use fixed-size chunks. Uses an LLM + Regex pipeline to split documents at logical semantic boundaries (e.g., "Article 21", "Section 4"), preserving legal context.
+- **Infrastructure:** Fully dockerized. Uses a `healthcheck` in Docker Compose to ensure the Qdrant Vector DB is fully ready before the bot application starts.
+- **Memory:** Uses `ConversationBufferWindowMemory` (k=5) to handle follow-up questions ("What is the penalty for *that*?").
+- **Safety:** Prevents hallucinations by strictly grounding answers in retrieved context.
+
+### PROJECT_3_DEEP_DIVE: MealMatch AI
+**Type:** Solo Project (Patent Filed).
+**Deployed Link:** `mealmatch-ai.vercel.app`
+**Summary:** Serverless food ordering app that generates meal combos strictly fitting *both* Budget & Calorie limits.
+**Commercial Potential:** Mrigank believes this has the highest commercial potential due to mass consumer appeal.
+**Technical "Flex":**
+- **Algorithm:** Uses a "Knapsack-style" optimization algorithm with **Heuristic Pruning**. It pre-sorts items by "efficiency" (calories/price) and stops recursion after finding the top 6 combos to prevent UI freezes (solving the O(n³) complexity issue).
+- **Compatibility Matrix:** Implemented a rule-based system to prevent culinary clashes (e.g., ensuring it doesn't suggest Rice + Pasta in the same combo).
+- **Architecture:** Client-side only (Serverless). Logic runs entirely in the browser.
+
+### PROJECT_4_DEEP_DIVE: JobFit (Resume Analyzer)
+**Type:** Solo Project.
+**Deployed Link:** `jobfit-analysis-ai.vercel.app`
+**Summary:** An agentic AI pipeline that screens resumes against job descriptions.
+**Technical "Flex":**
+- **Architecture:** Uses **LangGraph** to model the analysis as a State Machine (Extraction -> Job Analysis -> Profiling -> Compatibility Scoring).
+- **Security:** Implements "Direct-to-S3" uploads using AWS Presigned URLs with 5-minute expiry to bypass server bottlenecks and ensure security.
+- **Handling Hallucinations:** Uses Regex-based JSON extraction (`safe_parse_json`) to clean LLM outputs before rendering.
+
+### PROJECT_5_DEEP_DIVE: F&B Process Anomaly Detection
+**Type:** Solo Project (Industrial ML).
+**Repo:** `github.com/Mrigank005/F-B-Process-Anomaly-Detection-System`
+**Summary:** Industrial ML pipeline to detect defects in food batches (analyzing 1500+ batches across 11 parameters).
+**Technical "Flex":**
+- **Ensemble Model:** Combines 4 algorithms (Isolation Forest, One-Class SVM, Local Outlier Factor, Autoencoder). A batch is flagged only if ≥2 models agree (Consensus Voting).
+- **Explainability:** Integrated **SHAP** (Shapley Additive Explanations) to tell operators exactly *which* sensor (e.g., "Humidity") caused the alarm.
+- **Auto-Thresholding:** The Autoencoder dynamically sets its error threshold based on the 95th percentile of reconstruction error.
+
+### PROJECT_6_DEEP_DIVE: UPES Career Services Platform
+**Type:** Group Project (Teammates: Konal Puri, Aviral Khanna).
+**Mrigank's Role:** Built the Frontend (React/Vite) and designed AI Prompts.
+**Deployed Link:** `upes-samarth-internship.vercel.app`
+**Technical Details:**
+- **Attendance:** Interfaces with `navigator.mediaDevices` to capture live camera frames for attendance verification.
+- **AI Assessments:** Uses "Few-Shot Chain-of-Thought" prompts to synthesize a student's daily reports into tailored interview questions.
+- **UX:** Implemented "Mock" async behavior (simulated latency) to polish loading states before backend integration.
+
+### PROJECT_7_DEEP_DIVE: Better LinkedIn
+**Type:** Solo Project.
+**Deployed Link:** `better-linked-in.vercel.app`
+**Technical "Flex":**
+- **Performance:** Uses `react-window` for list virtualization (rendering only visible posts) to handle infinite feeds without lag.
+- **Custom Hooks:** Built `useStickySidebar` to mathematically calculate sticky positioning when CSS `position: sticky` fails in complex layouts.
+
+### LEADERSHIP_AND_SOFT_SKILLS
+**Leadership:**
+- **Role:** Joint Events Head at UPES ACM-W Student Chapter.
+- **Impact:** Organized 10+ events. Co-Convener for "Prodigy'25" Tech Fest, managing 1400+ participants and introducing 500+ freshers to tech.
+- **Philosophy:** "Everyone wants to be heard and feel like they are contributing to a goal."
+- **Conflict Resolution:** Approaches disagreements by presenting a logical case with supporting reasons.
+
+**Internship Experience:**
+- **Shramik Bharti NGO:** Maintained website and internal tools. Gained appreciation for grassroots social impact.
+
+**Why 7.8 CGPA?**
+- Mrigank prioritized hands-on innovation (building 7+ projects, filing 3 patents) over rote academic memorization.

models.py

@@ -0,0 +1,17 @@
+import os
+from dotenv import load_dotenv
+from google import genai
+
+load_dotenv()
+
+client = genai.Client(api_key=os.getenv("GOOGLE_API_KEY"))
+
+print("Fetching available models...")
+try:
+    # List all models and just print their names
+    # (The SDK returns an iterator, so we loop through it)
+    for m in client.models.list():
+        print(f"found: {m.name}")
+        
+except Exception as e:
+    print(f"❌ Error: {e}")

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.115.0
+uvicorn==0.30.6
+python-dotenv==1.0.1
+google-genai==1.0.0
+pinecone-client==5.0.1
+pydantic==2.9.2

scripts/ingest.py

@@ -0,0 +1,95 @@
+import os
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from dotenv import load_dotenv
+from google import genai
+from pinecone import Pinecone
+
+load_dotenv()
+
+# Initialize clients
+pc = Pinecone(api_key=os.getenv("PINECONE_API_KEY"))
+index = pc.Index("portfolio-chat")
+client = genai.Client(api_key=os.getenv("GOOGLE_API_KEY"))
+
+# Constants
+EMBEDDING_MODEL = "gemini-embedding-001"
+EMBEDDING_DIMENSION = 768
+DATA_FILE = Path(__file__).parent.parent / "data" / "knowledge_base.txt"
+
+
+def get_embedding(text: str) -> list[float]:
+    """Generate embedding for a given text."""
+    response = client.models.embed_content(
+        model=EMBEDDING_MODEL,
+        contents=text,
+        config={
+            "output_dimensionality": EMBEDDING_DIMENSION
+        }
+    )
+    return response.embeddings[0].values
+
+
+def load_and_chunk(file_path: Path) -> list[str]:
+    """Load text file and split into chunks by double newlines."""
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    
+    # Split by double newlines
+    chunks = [chunk.strip() for chunk in content.split("\n\n") if chunk.strip()]
+    return chunks
+
+
+def main():
+    print("=" * 50)
+    print("Portfolio Knowledge Base Ingestion Script")
+    print("=" * 50)
+    
+    # Step 1: Load and chunk the data
+    print(f"\n[1/3] Loading data from: {DATA_FILE}")
+    
+    if not DATA_FILE.exists():
+        print(f"ERROR: File not found: {DATA_FILE}")
+        sys.exit(1)
+    
+    chunks = load_and_chunk(DATA_FILE)
+    print(f"      Loaded {len(chunks)} chunks")
+    
+    # Step 2: Generate embeddings and prepare vectors
+    print(f"\n[2/3] Generating embeddings...")
+    vectors = []
+    
+    for i, chunk in enumerate(chunks):
+        print(f"      Processing chunk {i + 1}/{len(chunks)}...", end="\r")
+        
+        embedding = get_embedding(chunk)
+        vectors.append({
+            "id": str(i),
+            "values": embedding,
+            "metadata": {"text": chunk}
+        })
+    
+    print(f"      Generated {len(vectors)} embeddings" + " " * 20)
+    
+    # Step 3: Upsert to Pinecone
+    print(f"\n[3/3] Upserting to Pinecone...")
+    
+    # Upsert in batches of 100 (Pinecone best practice)
+    batch_size = 100
+    for i in range(0, len(vectors), batch_size):
+        batch = vectors[i:i + batch_size]
+        index.upsert(vectors=batch)
+        print(f"      Upserted batch {i // batch_size + 1}")
+    
+    print("\n" + "=" * 50)
+    print("SUCCESS: Knowledge base ingested!")
+    print(f"Total vectors: {len(vectors)}")
+    print("=" * 50)
+
+
+if __name__ == "__main__":
+    main()