Phase 1: RAG Pipeline working

.gitignore

@@ -0,0 +1,5 @@
+__pycache__
+.venv
+.env
+data
+.gradio

example_prompt.txt

@@ -0,0 +1,42 @@
+
+You are an expert anime recommendation assistant. A user has asked for recommendations, and I've retrieved some potentially relevant anime from the database.
+Your task is to:
+1. Analyze the user's request carefully, paying attention to specific preferences (tone, themes, etc.)
+2. Evaluate each retrieved anime against their user's criteria
+3. Select the 3 BEST matches that truly fit what they're asking for
+4. Explain why each recommendation fits their request
+
+User's Query:
+"Anime similar to Death Note but lighter in tone"
+
+Retrieved anime from semantic search:
+1. **Code Geass** (Score: 8.7/10, Scored by: 10000)
+  Genres: Action, Drama, Mecha
+  Synopsis: Lelouch, an exiled prince, gains the power of Geass and leads a rebellion against the Britannian Empire...
+
+2. **Monster** (Score: 8.9/10, Scored by: 100)
+  Genres: Mystery, Psychological, Thriller
+  Synopsis: Dr. Tenma saves a young boy's life, only to discover the boy grows up to be a dangerous serial killer...
+
+3. **Classroom of the Elite** (Score: 7.9/10, Scored by: 200000)
+  Genres: Drama, Psychological
+  Synopsis: In an elite school, students compete using strategy and manipulation to climb social ranks...
+
+
+Instructions:
+- If the user mentioned specific preferences (e.g., "lighter", "darker", "more action"), prioritize those
+- Don't just list all retrieved anime - SELECT the best 3 that truly match
+- For each recommendation, explain in 1-2 sentences WHY it matches their request
+- If some retrieved anime DON'T match the user's specific criteria, exclude them
+- Be honest if none of the retrieved anime are great matches
+
+Format your response as:
+**Recommendation 1: [Anime Title]**
+[1-2 sentence explanation of why it matches]
+
+**Recommendation 2: [Anime Title]**
+[1-2 sentence explanation]
+
+[Continue for 3 recommendations]
+
+If you think the retrieved anime don't match the request well, say so and explain what type of anime would be better.

info.txt

@@ -0,0 +1,13 @@
+demographics meaning in api:
+    It refers to target audiences
+        Kodomo: For young children (under 13 years old).
+        Shounen: Primarily targeted at young boys (ages 13-18).
+        Shoujo: Primarily targeted at young girls (ages 13-18).
+        Seinen: Primarily targeted at adult men (ages 19-40+).
+        Josei: Primarily targeted at adult women (ages 19-40+). 
+
+    Each API response can be different seasons of the same anime.
+    so one mal_id can be MHA: Season 1, other can be MHA: Season 2 and so on
+    Also, I just saw, in let's say MHA: Season 2, in synopsis, its just written, MHA anime season two, and no synpopsis.
+    So, also need to make it such that it get synopsis from whichever Mal_id's synopsis is written for that anime
+    

logger_config.py

@@ -0,0 +1,15 @@
+import logging
+import sys
+
+
+def setup_logging():
+    log_format = "%(asctime)s - %(levelname)s - [%(name)s - %(message)s]"
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format=log_format,
+        handlers=[
+            logging.StreamHandler(sys.stdout),  # Print to the console
+            logging.FileHandler("app.log")
+        ]
+    )

main.py

@@ -0,0 +1,13 @@
+import logging
+from logger_config import setup_logging
+
+setup_logging()
+logger = logging.getLogger(__name__)
+
+
+def main():
+    print("Hello from anime-rag-system!")
+
+
+if __name__ == "__main__":
+    main()

notebooks/01_embedding_experiments.ipynb

@@ -0,0 +1,347 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8e40675b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sentence_transformers import SentenceTransformer\n",
+    "import chromadb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "bac36205",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/pushkar/AllDocuments/EtE_projects/anime_rag_system\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "# BASE_DIR = Path(__file__).resolve().parent # if python file\n",
+    "BASE_DIR = Path.cwd().parent\n",
+    "print(BASE_DIR)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "2878800c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "client = chromadb.PersistentClient(path=BASE_DIR / \"data/embeddings/chroma_db\")\n",
+    "collection = client.get_collection(name=\"anime_collection\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "70b38ecc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "queries = [\n",
+    "    \"psychological thriller anime\",\n",
+    "    \"comedy slice of life school anime\",\n",
+    "    \"anime like Attack on Titan\",\n",
+    "    \"sad anime that will make me cry\"\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "672b383c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Query: psychological thriller anime: \n",
+      "1. Kimetsu no Yaiba Movie 1: Mugenjou-hen - Akaza Sairai (distance: 0.902)\n",
+      "2. Hoozuki no Reitetsu 2nd Season (distance: 0.912)\n",
+      "3. Mob Psycho 100 II (distance: 0.961)\n",
+      "4. Mob Psycho 100 III (distance: 1.003)\n",
+      "5. Akira (distance: 1.037)\n",
+      "6. Mob Psycho 100 (distance: 1.041)\n",
+      "7. Fujimoto Tatsuki 17-26 (distance: 1.056)\n",
+      "8. Guimi Zhi Zhu: Xiaochou Pian (distance: 1.057)\n",
+      "Query: comedy slice of life school anime: \n",
+      "1. 3-nen Z-gumi Ginpachi-sensei (distance: 0.759)\n",
+      "2. Kimi to Boku. 2 (distance: 0.793)\n",
+      "3. School Rumble (distance: 0.914)\n",
+      "4. Non Non Biyori Repeat (distance: 0.926)\n",
+      "5. Hidamari Sketch: Sae Hiro Sotsugyou-hen (distance: 0.930)\n",
+      "6. 5-toubun no Hanayome∽ (distance: 0.933)\n",
+      "7. Danshi Koukousei no Nichijou (distance: 0.935)\n",
+      "8. Kono Subarashii Sekai ni Shukufuku wo! 3: Bonus Stage (distance: 0.940)\n",
+      "Query: anime like Attack on Titan: \n",
+      "1. Shingeki no Kyojin Movie: Kanketsu-hen - The Last Attack (distance: 0.719)\n",
+      "2. Kidou Senshi Zeta Gundam (distance: 0.886)\n",
+      "3. Shingeki no Kyojin: The Final Season (distance: 0.937)\n",
+      "4. Shingeki no Kyojin: The Final Season Part 2 (distance: 0.941)\n",
+      "5. Shingeki no Kyojin (distance: 0.971)\n",
+      "6. Shingeki no Kyojin Season 2 (distance: 0.994)\n",
+      "7. Shingeki no Kyojin Season 3 Part 2 (distance: 1.011)\n",
+      "8. Shingeki no Kyojin OVA (distance: 1.034)\n",
+      "Query: sad anime that will make me cry: \n",
+      "1. Fujimoto Tatsuki 17-26 (distance: 0.990)\n",
+      "2. Osomatsu-san Movie (distance: 1.051)\n",
+      "3. Gintama: Dai Hanseikai (distance: 1.052)\n",
+      "4. Yuuki Yuuna wa Yuusha de Aru: Washio Sumi no Shou 3 - Yakusoku (distance: 1.094)\n",
+      "5. Tengoku Daimakyou (distance: 1.096)\n",
+      "6. Kimetsu no Yaiba Movie 1: Mugenjou-hen - Akaza Sairai (distance: 1.107)\n",
+      "7. Girls Band Cry (distance: 1.111)\n",
+      "8. Mahou Shoujo Madoka★Magica Movie 3: Hangyaku no Monogatari (distance: 1.121)\n"
+     ]
+    }
+   ],
+   "source": [
+    "for query in queries:\n",
+    "    print(f\"Query: {query}: \")\n",
+    "    results = collection.query(\n",
+    "        query_texts=[query],\n",
+    "        n_results=8\n",
+    "    )\n",
+    "\n",
+    "    for i, (title, distance) in enumerate(zip(\n",
+    "        [m[\"title\"] for m in results[\"metadatas\"][0]],\n",
+    "        results[\"distances\"][0]\n",
+    "    )):\n",
+    "        print(f\"{i+1}. {title} (distance: {distance:.3f})\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "a9843de5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def show_results(results):\n",
+    "    for i, (title, distance) in enumerate(zip(\n",
+    "        [m[\"title\"] for m in results[\"metadatas\"][0]],\n",
+    "        results[\"distances\"][0]\n",
+    "    )):\n",
+    "        print(f\"{i+1}. {title} (distance: {distance:.3f})\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "453ed4e7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "que = [\"Anime about a mage who goes on adventures\"]\n",
+    "\n",
+    "res1 = collection.query(query_texts=que,\n",
+    "                       n_results=20)\n",
+    "\n",
+    "res2 = collection.query(query_texts=que,\n",
+    "                        n_results=100,\n",
+    "                        where={\"score\":{\n",
+    "                            \"$gt\": 0\n",
+    "                        }})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "985018d1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Results without metadata filtering: \n",
+      "1. Meitantei Conan: Episode One - Chiisaku Natta Meitantei (distance: 1.009)\n",
+      "2. Magi: The Kingdom of Magic (distance: 1.035)\n",
+      "3. Guimi Zhi Zhu: Xiaochou Pian (distance: 1.072)\n",
+      "4. 3-nen Z-gumi Ginpachi-sensei (distance: 1.075)\n",
+      "5. Mahoutsukai no Yome: Hoshi Matsu Hito (distance: 1.088)\n",
+      "6. Magi: The Labyrinth of Magic (distance: 1.090)\n",
+      "7. Akagami no Shirayuki-hime 2nd Season (distance: 1.091)\n",
+      "8. Kimetsu no Yaiba Movie 1: Mugenjou-hen - Akaza Sairai (distance: 1.103)\n",
+      "9. Silent Witch: Chinmoku no Majo no Kakushigoto (distance: 1.117)\n",
+      "10. Meitantei Conan Movie 13: Shikkoku no Chaser (distance: 1.121)\n",
+      "11. Yuru Yuri San☆Hai! (distance: 1.126)\n",
+      "12. Gintama: Dai Hanseikai (distance: 1.139)\n",
+      "13. Zhu Xian 2nd Season (distance: 1.142)\n",
+      "14. Yuri!!! on Ice: Yuri Plisetsky GPF in Barcelona EX - Welcome to The Madness (distance: 1.144)\n",
+      "15. Mushoku Tensei: Isekai Ittara Honki Dasu (distance: 1.148)\n",
+      "16. Kono Subarashii Sekai ni Shukufuku wo! 3: Bonus Stage (distance: 1.149)\n",
+      "17. Lupin III vs. Meitantei Conan: The Movie (distance: 1.154)\n",
+      "18. xxxHOLiC Movie: Manatsu no Yoru no Yume (distance: 1.155)\n",
+      "19. Hoozuki no Reitetsu 2nd Season (distance: 1.156)\n",
+      "20. Tsubasa: Shunraiki (distance: 1.157)\n",
+      "Results with metadata filtering: \n",
+      "1 Meitantei Conan: Episode One - Chiisaku Natta Meitantei, \n",
+      "Genre: Adventure, Comedy, Mystery \n",
+      "Distance: 1.0094857215881348\n",
+      "1 Magi: The Kingdom of Magic, \n",
+      "Genre: Action, Adventure, Fantasy \n",
+      "Distance: 1.0348175764083862\n",
+      "1 Magi: The Labyrinth of Magic, \n",
+      "Genre: Action, Adventure, Fantasy \n",
+      "Distance: 1.0896832942962646\n",
+      "1 Zhu Xian 2nd Season, \n",
+      "Genre: Action, Adventure, Fantasy \n",
+      "Distance: 1.1424976587295532\n",
+      "1 Mushoku Tensei: Isekai Ittara Honki Dasu, \n",
+      "Genre: Adventure, Drama, Fantasy, Ecchi \n",
+      "Distance: 1.1479932069778442\n",
+      "1 Kono Subarashii Sekai ni Shukufuku wo! 3: Bonus Stage, \n",
+      "Genre: Adventure, Comedy, Fantasy \n",
+      "Distance: 1.1492812633514404\n",
+      "1 Tsubasa: Shunraiki, \n",
+      "Genre: Action, Adventure, Drama, Fantasy, Romance \n",
+      "Distance: 1.1567258834838867\n",
+      "1 Wanmei Shijie, \n",
+      "Genre: Action, Adventure, Fantasy \n",
+      "Distance: 1.1588501930236816\n",
+      "1 Meitantei Conan OVA 09: 10-nengo no Stranger, \n",
+      "Genre: Adventure, Comedy, Mystery \n",
+      "Distance: 1.1683908700942993\n",
+      "1 Meitantei Conan Movie 03: Seikimatsu no Majutsushi, \n",
+      "Genre: Adventure, Comedy, Mystery \n",
+      "Distance: 1.183741807937622\n",
+      "1 Golden Boy, \n",
+      "Genre: Adventure, Comedy, Ecchi \n",
+      "Distance: 1.1899913549423218\n",
+      "1 Mirai Shounen Conan, \n",
+      "Genre: Adventure, Drama, Sci-Fi \n",
+      "Distance: 1.192782998085022\n",
+      "1 Mushoku Tensei: Isekai Ittara Honki Dasu Part 2, \n",
+      "Genre: Adventure, Drama, Fantasy, Ecchi \n",
+      "Distance: 1.2001222372055054\n",
+      "1 Majo no Takkyuubin, \n",
+      "Genre: Adventure, Award Winning, Comedy, Drama, Fantasy \n",
+      "Distance: 1.2021398544311523\n",
+      "1 Naruto, \n",
+      "Genre: Action, Adventure, Fantasy \n",
+      "Distance: 1.2085628509521484\n",
+      "1 Sword Art Online: Progressive Movie - Hoshi Naki Yoru no Aria, \n",
+      "Genre: Action, Adventure, Fantasy \n",
+      "Distance: 1.2172694206237793\n",
+      "1 Ginga Sengoku Gunyuuden Rai, \n",
+      "Genre: Adventure, Romance, Sci-Fi \n",
+      "Distance: 1.2243961095809937\n",
+      "1 Xian Ni, \n",
+      "Genre: Action, Adventure, Fantasy \n",
+      "Distance: 1.2341101169586182\n",
+      "1 Overlord, \n",
+      "Genre: Action, Adventure, Fantasy \n",
+      "Distance: 1.2380468845367432\n",
+      "1 Akatsuki no Yona OVA, \n",
+      "Genre: Adventure, Fantasy \n",
+      "Distance: 1.2383925914764404\n",
+      "1 Mushishi Zoku Shou: Suzu no Shizuku, \n",
+      "Genre: Adventure, Mystery, Slice of Life, Supernatural \n",
+      "Distance: 1.2392939329147339\n",
+      "1 Shen Yin Wangzuo Movie: Yi Lai Ke Si Chuanqi, \n",
+      "Genre: Action, Adventure, Fantasy \n",
+      "Distance: 1.239490270614624\n",
+      "1 Dragon Ball, \n",
+      "Genre: Action, Adventure, Comedy, Fantasy \n",
+      "Distance: 1.2412399053573608\n",
+      "1 Wu Liuqi: Xuanwu Guo Pian, \n",
+      "Genre: Action, Adventure, Comedy, Drama, Mystery \n",
+      "Distance: 1.242012858390808\n",
+      "1 Meitantei Conan, \n",
+      "Genre: Adventure, Comedy, Mystery \n",
+      "Distance: 1.2530790567398071\n",
+      "1 Kono Subarashii Sekai ni Shukufuku wo! 2, \n",
+      "Genre: Adventure, Comedy, Fantasy \n",
+      "Distance: 1.2592735290527344\n",
+      "1 Fanren Xiu Xian Chuan: Xinghai Feichi Prologue, \n",
+      "Genre: Action, Adventure, Fantasy \n",
+      "Distance: 1.264496922492981\n",
+      "1 Saint Seiya: The Lost Canvas - Meiou Shinwa 2, \n",
+      "Genre: Action, Adventure, Fantasy \n",
+      "Distance: 1.267714023590088\n",
+      "1 Meitantei Conan Movie 08: Ginyoku no Magician, \n",
+      "Genre: Adventure, Comedy, Mystery \n",
+      "Distance: 1.2713207006454468\n",
+      "1 Fullmetal Alchemist: Brotherhood Specials, \n",
+      "Genre: Action, Adventure, Drama, Fantasy \n",
+      "Distance: 1.273901343345642\n",
+      "1 Naruto: Shippuuden, \n",
+      "Genre: Action, Adventure, Fantasy \n",
+      "Distance: 1.2760953903198242\n",
+      "1 Tenkuu no Shiro Laputa, \n",
+      "Genre: Adventure, Award Winning, Fantasy \n",
+      "Distance: 1.278309941291809\n",
+      "1 Ie Naki Ko Remy, \n",
+      "Genre: Adventure, Drama \n",
+      "Distance: 1.2802643775939941\n",
+      "1 Yi Nian Yong Heng 3rd Season, \n",
+      "Genre: Action, Adventure, Comedy, Fantasy \n",
+      "Distance: 1.284270167350769\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Results without metadata filtering: \")\n",
+    "show_results(res1)\n",
+    "\n",
+    "print(\"Results with metadata filtering: \")\n",
+    "i = 0;\n",
+    "for _, (title, genres, distance) in enumerate(zip([m[\"title\"] for m in res2[\"metadatas\"][0]], [m.get(\"genres\", \"Unknown\") for m in res2[\"metadatas\"][0]], res2[\"distances\"][0])):\n",
+    "    if \"adventure\" in genres.lower():\n",
+    "        print(f\"{i + 1} {title}, \\nGenre: {genres} \\nDistance: {distance}\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b6e41bbf",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "42413036",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "anime-rag-system",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.14.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "anime-rag-system"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11,<3.14"
+dependencies = [
+    "chromadb>=0.5.0",
+    "fastapi[all]>=0.122.0",
+    "gradio>=6.2.0",
+    "langchain>=1.1.3",
+    "langchain-groq>=1.1.1",
+    "pandas>=2.3.3",
+    "python-dotenv>=1.2.1",
+    "requests>=2.32.5",
+    "sentence-transformers>=5.2.0",
+    "torch>=2.9.1",
+    "torchvision>=0.24.1",
+    "uvicorn>=0.38.0",
+]
+
+[tool.uv.sources]
+torch = { index = "pytorch-cpu" }
+torchvision = { index = "pytorch-cpu" }
+
+[[tool.uv.index]]
+name = "pytorch-cpu"
+url = "https://download.pytorch.org/whl/cpu"
+explicit = true
+
+[dependency-groups]
+dev = [
+    "ipykernel>=7.1.0",
+    "jupyter>=1.1.1",
+    "pytest>=9.0.2",
+]

src/api/main.py

@@ -0,0 +1,110 @@
+from fastapi import FastAPI, HTTPException, status
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+import uvicorn
+from src.api.schemas import RecommendationRequest, RecommendationResponse
+import time
+
+from src.retrieval.rag_pipeline import AnimeRAGPipeline
+
+app = FastAPI(title="Anime Recommendation API",
+              description="RAG-powered anime recommendation system",
+              version="1.0.0")
+
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"]
+)
+
+pipeline = None
+
+
+def get_pipeline():
+    """Lazy initialization of pipeline"""
+    global pipeline
+    if pipeline is None:
+        pipeline = AnimeRAGPipeline(retriever_k=10)
+    return pipeline
+
+
+@app.get("/")
+async def root():
+    """Healthcheck Endpoint"""
+    return {
+        "status": "online",
+        "message": "Anime recommendation API",
+        "version": "1.0.0"
+    }
+
+
+@app.post("/recommend", response_model=RecommendationResponse)
+async def get_recommendations(request: RecommendationRequest):
+    """
+    Get anime recommendation based on user query
+
+    Example request:
+    ```json
+    {
+        "query": "Anime similar to Death Note but lighter",
+        "n_results": 5,
+        "min_score": 7.5
+    }
+    ```
+    """
+    try:
+        rag_pipeline = get_pipeline()
+
+        rag_pipeline.recommendation_n = request.n_results
+
+        filters = {}
+        if request.min_score:
+            filters["min_score"] = request.min_score
+
+        if request.genre_filter:
+            filters["genre_filter"] = request.genre_filter
+
+        start_time = time.time()
+        result = rag_pipeline.recommend(
+            user_query=request.query,
+            filters=filters if filters else None
+        )
+        end_time = time.time()
+        return RecommendationResponse(
+            query=result["query"],
+            recommendations=result["recommendations"],
+            retrieved_count=result["retrieved_count"],
+            metadata={
+                "model": "llama-3.3-70b-versatile",
+                "retriever_k": rag_pipeline.retriever_k,
+                "Time taken for LLM + vector search": str(end_time - start_time)
+            }
+        )
+
+    except Exception as e:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                            detail=f"Error processing request: {str(e)}")
+
+
+@app.get("/stats")
+async def get_stats():
+    """Get system statistics"""
+    rag_pipeline = get_pipeline()
+
+    return {
+        "total_anime": rag_pipeline.retriever.collection.count(),
+        "embedding_model": "all-MiniLM-L6-v2",
+        "llm_model": "llama-3.1-70b-versatile",
+        "retrieval_k": rag_pipeline.retriever_k
+    }
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "src.api.main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True
+    )

src/api/schemas.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel, Field
+
+class RecommendationRequest(BaseModel):
+    query: str = Field(description="User's anime recommendation request")
+    n_results: int | None = Field(5, description="Number of recommendations to return")
+    min_score: float | None = Field(None, description="Minimum MyAnimeList Score filter")
+    genre_filter: str | None = Field(None, description="Filter by genre")
+
+class RecommendationResponse(BaseModel):
+    query: str
+    recommendations: str
+    retrieved_count: int
+    metadata: dict = {}

src/data_ingestion/clean_data.py

@@ -0,0 +1,144 @@
+import json
+import pandas as pd
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class AnimeDataCleaner:
+    """Cleans and prepares anime data for embeddings"""
+
+    @staticmethod
+    def load_raw_data(filepath: str = "data/raw/raw_anime.json") -> list[dict]:
+        """Load raw anime data"""
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+    @staticmethod
+    def clean_synopsis(synopsis: str) -> str:
+        """Clean synopsis text"""
+        if not synopsis or synopsis == "":
+            return "No synopsis available."
+
+        synopsis = synopsis.replace("[Written by MAL Rewrite]", "")
+        synopsis.strip()
+
+        return synopsis
+
+    @staticmethod
+    def create_searchable_text(anime: dict) -> str:
+        """
+        Combine multiple fields into one searchable text.
+        This is what we'll embed!
+
+        Format: Title. Genres. Synopsis.
+        """
+        title = anime.get("title")
+        title_en = anime.get("title_english")
+
+        title_text = title
+        if title_en and title_en != title:
+            title_text = f"{title} ({title_en})"
+
+        genres = ", ".join(anime.get("genres", []))
+        themes = ", ".join(anime.get("themes", []))
+        demographics = ", ".join(anime.get("demographics", []))
+
+        genre_parts = [p for p in [genres, themes, demographics] if p]
+        genre_text = ". ".join(genre_parts) if genre_parts else ""
+
+        synopsis = AnimeDataCleaner.clean_synopsis(anime.get("synopsis", ""))
+
+        searchable_text = f"{title_text}. {genre_text}. {synopsis}"
+
+        return searchable_text.strip()
+
+    @staticmethod
+    def filter_valid_anime(anime_list: list[dict]) -> list[dict]:
+        """Remove anime without synopsis or essential fields"""
+        valid_anime = []
+
+        for anime in anime_list:
+            if not anime.get("title"):
+                continue
+
+            synopsis = anime.get("synopsis", "")
+            if not synopsis or len(synopsis) < 50:
+                continue  # Later modify this part to get custom synopsis from online sources
+
+            valid_anime.append(anime)
+
+        print(f"Filtered {len(anime_list)} -> {len(valid_anime)} animes")
+        logger.info(f"Filtered {len(anime_list)} -> {len(valid_anime)} animes")
+
+        return valid_anime
+
+    @staticmethod
+    def prepare_for_embedding(anime_list: list[dict]) -> pd.DataFrame:
+        """
+        Prepare final dataset for embedding
+
+        Returns dataframe with columns:
+        - mal_id: unique identifier
+        - searchable_text: what to embed
+        - metadata: everything else (for filtering/display)
+        """
+
+        records = []
+
+        for anime in anime_list:
+            record = {
+                "mal_id": anime["mal_id"],
+                "title": anime["title"],
+                "searchable_text": AnimeDataCleaner.create_searchable_text(anime),
+                # Rest is metadata for filtering and display
+                "genres": ", ".join(anime.get("genres", [])),
+                "score": anime.get("score"),
+                "episodes": anime.get("episodes"),
+                "type": anime.get("type"),
+                "year": anime.get("year"),
+                "synopsis": AnimeDataCleaner.clean_synopsis(anime.get("synopsis", "")),
+                "aired_from": anime.get("aired_from", ""),
+                "aired_to": anime.get("aired_to", ""),
+                "rating": anime.get("rating"),
+                "scored_by": anime.get("scored_by"),
+            }
+
+            records.append(record)
+
+        df = pd.DataFrame(records)
+        return df
+
+    @staticmethod
+    def save_processed_data(df: pd.DataFrame, filepath: str = "data/processed/anime_clean.csv"):
+        """Save processed data"""
+        df.to_csv(filepath, index=False, encoding="utf-8")
+        logger.info(f"Saved {len(df)} anime to {filepath}")
+
+        json_path = filepath.replace(".csv", ".json")
+        df.to_json(json_path, orient="records", indent=2, force_ascii=False)
+
+        logger.info(f"Also saved to {json_path}")
+
+
+if __name__ == "__main__":
+    cleaner = AnimeDataCleaner()
+
+    print("Loading raw data....")
+    raw_animes = cleaner.load_raw_data()
+
+    valid_animes = cleaner.filter_valid_anime(raw_animes)
+
+    print("\nPreparing data for embedding...")
+    df = cleaner.prepare_for_embedding(valid_animes)
+
+    cleaner.save_processed_data(df)
+
+    print("\nSample searchable text:")
+    print(df.iloc[0]["searchable_text"][:500])
+
+    print(f"\nDataset statistics:")
+    print(f"Total anime: {len(df)}")
+    print(
+        f"Average text length: {df['searchable_text'].str.len().mean():.0f} chars")
+    print(f"Score range: {df['score'].min():.1f} - {df['score'].max():.1f}")

src/data_ingestion/create_embeddings.py

@@ -0,0 +1,153 @@
+import pandas as pd
+from sentence_transformers import SentenceTransformer
+import chromadb
+from chromadb.config import Settings
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class EmbeddingPipeline:
+    """Creates embeddings and store in ChromaDB"""
+
+    def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
+        """
+        Initialize embedding model and ChromaDB client
+
+        Args:
+            model_name: HuggingFace model for embeddings
+                       all-MiniLM-L6-v2: Fast, good quality, 384 dims
+        """
+        logger.info(f"Loading embedding model: {model_name}")
+        self.model = SentenceTransformer(model_name)
+
+        self.chroma_client = chromadb.PersistentClient(
+            path="data/embeddings/chroma_db")
+
+        self.use_existing_embeddings = False
+        print("ChromaDB initialized at data/embeddings/chroma_db")
+
+    def create_or_get_collection(self, collection_name: str = "anime_collection"):
+        """Create or get existing collection"""
+        try:
+            collection = self.chroma_client.get_collection(collection_name)
+            logger.info(f"Found existing collection: {collection_name}")
+            logger.info(f"Current count: {collection.count()} documents")
+
+            user_input = input("Reset collection? (y/n): ")
+            if user_input.lower() == "y":
+                self.chroma_client.delete_collection(collection_name)
+                collection = self.chroma_client.create_collection(
+                    collection_name)
+                logger.info("Collection reset")
+            else:
+                self.use_existing_embeddings = True
+
+        except:
+            collection = self.chroma_client.create_collection(collection_name)
+            logger.info(f"Created new collection: {collection_name}")
+
+        return collection
+
+    def embed_texts(self, texts: list[str], batch_size: int = 32) -> list[list[float]] | None:
+        """
+        Create embeddings for texts
+
+        Args:
+            texts: List of texts to embed
+            batch_size: Process in batches for efficiency
+        """
+
+        if self.use_existing_embeddings == False:
+            logger.info(f"Embedding {len(texts)} texts...")
+
+            embeddings = self.model.encode(
+                sentences=texts,
+                batch_size=batch_size,
+                show_progress_bar=True,
+                convert_to_numpy=True
+            )
+
+            return embeddings.tolist()
+
+        else:
+            logger.info(f"Using existing stored embeddings.")
+
+    def store_in_chromadb(self, collection, df: pd.DataFrame, embeddings: list[list[float]]):
+        """
+        Store embeddings and metadata in ChromaDB
+
+        Args:
+            collection: ChromaDB collection,
+            df: DataFrame with anime data,
+            embeddings: Pre_commputed embeddings
+        """
+
+        logger.info("Storing in ChromaDB...")
+
+        ids = [str(mal_id) for mal_id in df["mal_id"].tolist()]
+        documents = df["searchable_text"].tolist()
+
+        # Metadata
+        metadatas = []
+        for _, row in df.iterrows():
+            metadata = {
+                "title": row["title"],
+                "genres": row["genres"],
+                "score": float(row["score"]) if pd.notna(row["score"]) else 0.0,
+                "type": row["type"] if pd.notna(row["type"]) else "Unknown",
+                "year": int(row["year"]) if pd.notna(row["year"]) else 0,
+                "synopsis": row["synopsis"][:500],
+                "rating": row["rating"] if pd.notna(row["rating"]) else "Rating Unspecified",
+                "scored_by": row['scored_by'],
+            }
+            metadatas.append(metadata)
+
+        collection.add(
+            ids=ids,
+            embeddings=embeddings,
+            documents=documents,
+            metadatas=metadatas
+        )
+
+        logger.info(f"Stored {len(ids)} animes in ChromaDB")
+        logger.info(f"Collection now has {collection.count()} documents")
+
+    def run_pipeline(self, csv_path: str = 'data/processed/anime_clean.csv'):
+        """Run complete embedding pipeline"""
+
+        logger.info("Loading processed data...")
+        df = pd.read_csv(csv_path)
+        logger.info(f"Loaded {len(df)} animes")
+
+        collection = self.create_or_get_collection()
+
+        if self.use_existing_embeddings == False:
+            embeddings = self.embed_texts(df["searchable_text"].tolist())
+            if embeddings:
+                self.store_in_chromadb(collection, df, embeddings)
+
+        logger.info("Embedding pipeline complete !")
+
+        return collection
+
+
+if __name__ == "__main__":
+    pipeline = EmbeddingPipeline()
+    collection = pipeline.run_pipeline()
+
+    print("\n--- Testing vector search ---")
+    query = "Anime with female main character on adventure"
+
+    print(f"Query: {query}")
+
+    results = collection.query(query_texts=[query], n_results=15)
+
+    print("\n--- TOP 5 RESULTS ---")
+
+    for i, (title, distance) in enumerate(zip(
+        [m["title"] for m in results["metadatas"][0]],
+        results["distances"][0]
+    )):
+        print(f"{i+1}. {title} (distance: {distance:.3f})")

src/data_ingestion/fetch_anime.py

@@ -0,0 +1,109 @@
+import requests
+import time
+import json
+import logging
+from datetime import datetime
+
+
+def convert_datetime(dt: str | None):
+    if not dt:
+        return None
+    return datetime.fromisoformat(dt)
+
+
+logger = logging.getLogger(__name__)
+
+
+class AnimeDataFetcher:
+    """Fetches anime data from Jikan API (Unofficial MyAnimeList API)"""
+
+    BASE_URL = "https://api.jikan.moe/v4/"
+
+    def __init__(self):
+        self.session = requests.Session()
+
+    def fetch_top_anime(self, limit: int = 100) -> list[dict]:
+        """
+        Fetches top 'limit' animes from MyAnimeLists
+        Args:
+            limit: Number of anime to fetch(max ~500 with pagination)
+        Returns:
+            List of anime dictionaries
+        """
+
+        all_animes = []
+        page = 1
+        per_page = 25
+
+        while len(all_animes) < limit:
+            try:
+                response = self.session.get(
+                    f"{self.BASE_URL}top/anime",
+                    params={"page": page, "limit": per_page}
+                )
+                response.raise_for_status()
+                logger.info(
+                    f"Response received successfully: {response.status_code} !!")
+
+                data = response.json()
+                anime_list = data.get("data", [])
+                if not anime_list:
+                    break
+
+                all_animes.extend(anime_list)
+                logger.info(
+                    f"Fetched page {page}: {len(anime_list)} animes. Total: {len(all_animes)}")
+
+                page += 1
+                time.sleep(1.5)
+
+            except Exception as e:
+                logger.error(f"Error fetching page {page}: {e}")
+                break
+
+        return all_animes[:limit]
+
+    def extract_relevant_fields(self, anime: dict) -> dict:
+        """Extract only fields we need for RAG"""
+        return {
+            "mal_id": anime.get("mal_id"),
+            "title": anime.get("title"),
+            "title_english": anime.get("title_english"),
+            "synopsis": anime.get("synopsis"),
+            "genres": [g["name"] for g in anime.get("genres", [])],
+            "themes": [t["name"] for t in anime.get("themes", [])],
+            "demographics": [d["name"] for d in anime.get("demographics", [])],
+            "type": anime.get("type"),
+            "episodes": anime.get("episodes"),
+            "score": anime.get("score"),
+            "scored_by": anime.get("scored_by"),
+            "rank": anime.get("rank"),
+            "popularity": anime.get("popularity"),
+            "year": anime.get("year"),
+            "rating": anime.get("rating"),
+            "season": anime.get("season"),
+            "aired_from": anime.get("aired", {}).get("from", ""),
+            "aired_to": anime.get("aired", {}).get("to", ""),
+            "favorites": anime.get("favorites")
+        }
+
+    def save_raw_data(self, anime_list: list[dict], filename: str = "raw_anime.json"):
+        """Save raw anime data to file"""
+        with open(f"data/raw/{filename}", "w", encoding="utf-8") as f:
+            json.dump(anime_list, f, indent=2, ensure_ascii=False)
+
+        print(f"Saved {len(anime_list)} anime to data/raw/{filename}")
+
+
+if __name__ == "__main__":
+    fetcher = AnimeDataFetcher()
+
+    logger.info("Fetching top anime from MyAnimeList...")
+    raw_anime = fetcher.fetch_top_anime(limit=1000)
+
+    processed_anime = [fetcher.extract_relevant_fields(a) for a in raw_anime]
+
+    fetcher.save_raw_data(processed_anime)
+
+    print("\nSample anime: ")
+    print(json.dumps(processed_anime[0], indent=2, ensure_ascii=False))

src/llm/groq_client.py

@@ -0,0 +1,67 @@
+import os
+from groq import Groq
+from dotenv import load_dotenv
+import logging
+
+load_dotenv()
+logger = logging.getLogger(__name__)
+
+
+class GroqLLM:
+    """Wrapper for Groq API"""
+
+    def __init__(self, model: str = "llama-3.3-70b-versatile"):
+        """
+        Initialize Groq Client
+
+        Available models:
+        - llama-3.3-70b-versatile: Best reasoning, slower
+        - llama-3.1-8b-instant: Faster, good enough for most tasks
+        """
+
+        self.client = Groq()
+        self.model = model
+
+        logger.info(f"Initialized Groq with model {self.model}")
+
+    def generate(
+            self,
+            prompt: str,
+            system_prompt: str = """You are a helpful anime recommendation assistant""",
+            temperature: float = 0.7,
+            max_tokens: int = 1024
+    ):
+        """
+        Generate completion from prompt
+
+        Args:
+            prompt: User message,
+            system_prompt: System instructions,
+            temperature: Creativity (0=deterministic, 1=creative),
+            max_tokens: Max response length
+        """
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
+
+            return response.choices[0].message.content
+        except Exception as e:
+            logger.error(f"Groq API error: {e}")
+            return "Sorry, I encountered an error generating the response"
+
+
+if __name__ == '__main__':
+    llm = GroqLLM()
+
+    response = llm.generate(prompt="Explain what makes Death Note a good anime",
+                            temperature=0.9
+                            )
+    print("LLM Response::")
+    print(response)

src/llm/prompts.py

@@ -0,0 +1,124 @@
+"""
+Prompt Templates for anime recommendation system
+"""
+
+
+def create_recommendation_prompt(
+        user_query: str,
+        retrieved_animes: list,
+        n_recommendations: int | None = 5
+):
+    """
+    Create prompt for LLM to reason about recommendations
+
+    Args:
+        user_query: Original user question,
+        retrieved_animes: List of dict from vector search,
+        n_recommendations: How many to recommend
+    """
+
+    context_parts = []
+    for i, anime in enumerate(retrieved_animes, 1):
+        context_parts.append(
+            f"{i}. **{anime['title']}** (Score: {anime['score']}/10, Scored by: {anime['scored_by']})\n"
+            f"  Genres: {anime['genres']}\n"
+            f"  Synopsis: {anime['synopsis']}\n"
+        )
+
+    context = "\n".join(context_parts)
+
+    prompt = f"""
+You are an expert anime recommendation assistant. A user has asked for recommendations, and I've retrieved some potentially relevant anime from the database.
+Your task is to:
+1. Analyze the user's request carefully, paying attention to specific preferences (tone, themes, etc.)
+2. Evaluate each retrieved anime against their user's criteria
+3. Select the {n_recommendations} BEST matches that truly fit what they're asking for
+4. Explain why each recommendation fits their request
+
+User's Query:
+"{user_query}"
+
+Retrieved anime from semantic search:
+{context}
+
+Instructions:
+- If the user mentioned specific preferences (e.g., "lighter", "darker", "more action"), prioritize those
+- Don't just list all retrieved anime - SELECT the best {n_recommendations} that truly match
+- For each recommendation, explain in 1-2 sentences WHY it matches their request
+- If some retrieved anime DON'T match the user's specific criteria, exclude them
+- Be honest if none of the retrieved anime are great matches
+
+Format your response as:
+**Recommendation 1: [Anime Title]**
+[1-2 sentence explanation of why it matches]
+
+**Recommendation 2: [Anime Title]**
+[1-2 sentence explanation]
+
+[Continue for {n_recommendations} recommendations]
+
+If you think the retrieved anime don't match the request well, say so and explain what type of anime would be better."""
+
+    return prompt
+
+
+def create_system_prompt() -> str:
+    """
+    System prompt for the anime assistant
+    """
+    return """
+    You are an expert anime recommendation assistant with deep knowledge of anime themes, genres, and storytelling styles. 
+
+    Your strengths:
+    - Understanding nuanced preferences (tone, pacing, themes)
+    - Explaining WHY an anime matches a request
+    - Being honest when recommendations aren't perfect matches
+
+    Your approach:
+    - Prioritize the user's specific criteria over generic similarity
+    - Provide thoughtful, personalized explanations
+    - Focus on quality over quantity
+    """
+
+
+if __name__ == '__main__':
+    mock_animes = [
+        {
+            "title": "Code Geass",
+            "genres": "Action, Drama, Mecha",
+            "score": 8.7,
+            "scored_by": 10000,
+            "synopsis": "Lelouch, an exiled prince, gains the power of Geass and leads a rebellion against the Britannian Empire..."
+        },
+        {
+            "title": "Monster",
+            "genres": "Mystery, Psychological, Thriller",
+            "score": 8.9,
+            "scored_by": 100,
+            "synopsis": "Dr. Tenma saves a young boy's life, only to discover the boy grows up to be a dangerous serial killer..."
+        },
+        {
+            "title": "Classroom of the Elite",
+            "genres": "Drama, Psychological",
+            "score": 7.9,
+            "scored_by": 200000,
+            "synopsis": "In an elite school, students compete using strategy and manipulation to climb social ranks..."
+        }
+    ]
+
+    prompt = create_recommendation_prompt(
+        user_query="Anime similar to Death Note but lighter in tone",
+        retrieved_animes=mock_animes,
+        n_recommendations=3
+    )
+
+    print("Generated Prompt:")
+    print("=" * 80)
+    print(prompt)
+    print("=" * 80)
+
+    # Save to file for inspection
+    with open("example_prompt.txt", "w") as f:
+        f.write(prompt)
+
+    print("\nPrompt saved to example_prompt.txt")

src/retrieval/rag_pipeline.py

@@ -0,0 +1,138 @@
+from src.retrieval.vector_search import AnimeRetriever
+from src.llm.groq_client import GroqLLM
+from src.llm.prompts import create_recommendation_prompt, create_system_prompt
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class AnimeRAGPipeline:
+    def __init__(
+            self,
+            retriever: AnimeRetriever | None = None,
+            llm: GroqLLM | None = None,
+            retriever_k: int = 10,
+            recommendation_n: int | None = 5
+    ):
+        """ 
+        Initialize RAG Pipeline
+
+        Args:
+            retriever: AnimeRetriever instance (created if None)
+            llm: GroqLLM instance (created if None)
+            retrieval_k: How many anime to retrieve from vector search
+            recommendation_n: How many to recommend in final output
+        """
+        self.retriever = retriever or AnimeRetriever()
+        self.llm = llm or GroqLLM(model="llama-3.3-70b-versatile")
+        self.retriever_k = retriever_k
+        self.recommendation_n = recommendation_n
+
+        logger.info("RAG Pipeline initialized")
+        logger.info(f" - Retrieve top {retriever_k} anime from vector search")
+        logger.info(
+            f" - LLM reasons and recommends top {recommendation_n} anime")
+
+    def recommend(
+            self,
+            user_query: str,
+            filters: dict | None = None
+    ) -> dict:
+        """
+        Get anime recommendations from user query
+
+        Args:
+            user_query: User's request (e.g., "Anime like death note for lighter")
+            filters: Optional filters (min_score, genre_filter)
+
+        Returns:
+            Dict with:
+            - query: original query
+            - retrieved_count: how many retrieved
+            - recommendations: LLM Response
+            - retrieved_anime: raw retrieval results(for debugging)
+        """
+        logger.info(f"\n----Processing query: {user_query}-----\n")
+
+        logger.info(f"\n[1/3] Retrieving from vector database...")
+        filters = filters or {}
+
+        retrieved_animes = self.retriever.search(
+            query=user_query,
+            n_results=self.retriever_k,
+            **filters
+        )
+
+        logger.info(f"\n[2/3] Creating prompt with retrieved content...")
+        prompt = create_recommendation_prompt(
+            user_query=user_query,
+            retrieved_animes=retrieved_animes,
+            n_recommendations=self.recommendation_n
+        )
+
+        logger.info(f"\n[3/3] LLM Reasoning about recommendations...")
+        system_prompt = create_system_prompt()
+
+        recommendations = self.llm.generate(
+            prompt=prompt,
+            system_prompt=system_prompt,
+            temperature=0.4,
+            max_tokens=1500
+        )
+
+        logger.info("\n---Generated Recommendations---")
+
+        return {
+            "query": user_query,
+            "retrieved_count": len(retrieved_animes),
+            "recommendations": recommendations,
+            "retrieved_animes": retrieved_animes
+        }
+
+    def recommend_streaming(self, user_query: str, filters: dict | None = None):
+        """
+        Streaming version for real-time display
+        """
+        # Use it in FastAPI later
+        return self.recommend(user_query, filters)
+
+
+if __name__ == "__main__":
+    import json
+
+    pipeline = AnimeRAGPipeline(
+        retriever_k=10,
+        recommendation_n=5
+    )
+
+    test_queries = [
+        "Anime similar to Death Note but lighter in tone",
+        "Romantic comedy set in high school",
+        "Dark psychological thriller",
+        "Action anime with great animation and epic fights"
+    ]
+
+    for query in test_queries:
+        result = pipeline.recommend(user_query=query)
+
+        print(f"-------\nQuery: {query}:::\n-----")
+
+        print(f"\nRecommendations:\n---------------")
+
+        print(result["recommendations"])
+
+        # Save results for inspection
+        filename = f"test_result_{query[:30].replace(' ', '_')}.json"
+        with open(f"data/{filename}", "w") as f:
+            json.dump({
+                "query": result["query"],
+                "retrieved_titles": [a["title"] for a in result["retrieved_animes"]],
+                "recommendations": result["recommendations"]
+            }, f, indent=2)
+
+        print(f"\nSaved to data/{filename}")
+        print("\n" + "="*80 + "\n")
+
+        # Pause between queries to respect rate limits
+        import time
+        time.sleep(2)

src/retrieval/vector_search.py

@@ -0,0 +1,109 @@
+import chromadb
+from sentence_transformers import SentenceTransformer
+
+
+class AnimeRetriever:
+    """Handles anime retrieval from ChromaDB"""
+
+    def __init__(self,
+                 chroma_path: str = "data/embeddings/chroma_db",
+                 collection_name: str = "anime_collection",
+                 model: str = "all-MiniLM-L6-v2"):
+        self.client = chromadb.PersistentClient(chroma_path)
+        self.collection = self.client.get_collection(collection_name)
+        self.model = SentenceTransformer(model)
+
+        print(f"Loaded collection with {self.collection.count()} anime")
+
+    def search(
+            self,
+            query: str,
+            n_results: int = 5,
+            genre_filter: str | None = None,
+            min_score: float | None = None
+    ) -> list[dict]:
+        """
+        Search for anime similar to query
+
+        Args:
+            query: User search query
+            n_results: Number of results to return
+            genre_filter: Optional genre to filter by
+            min_score: Minimum MAL score (e.g., 7.0)
+
+        Returns:
+            List of dicts with anime info
+        """
+        where_clause = {}
+        if min_score:
+            where_clause["score"] = {"$gte": min_score}
+
+        # Genre Filtering later
+
+        results = self.collection.query(
+            query_texts=[query],
+            n_results=n_results * 2 if genre_filter else n_results,
+            where=where_clause if where_clause else None
+        )
+
+        anime_list = []
+        for i in range(len(results["ids"][0])):
+            metadata = results["metadatas"][0][i]  # type: ignore
+            distance = results["distances"][0][i]  # type: ignore
+
+            # Genre filtering (if specified)
+            if genre_filter:
+                if genre_filter.lower() not in metadata["genres"].lower(): # type: ignore
+                    continue
+
+            anime_info = {
+                "mal_id": results["ids"][0][i],
+                "title": metadata["title"],
+                "genres": metadata["genres"],
+                "score": metadata["score"],
+                "type": metadata["type"],
+                "year": metadata["year"],
+                "synopsis": metadata["synopsis"],
+                "distance": distance,
+                "scored_by": metadata["scored_by"],
+                "relevance_score": 1 - distance  # Convert distance to similarity
+            }
+            anime_list.append(anime_info)
+
+            if len(anime_list) >= n_results:
+                break
+
+        return anime_list
+
+    def get_by_title(self, title: str) -> dict | None:
+        """Get anime by exact or partial title match"""
+        # Search with title as query
+        results = self.search(query=title, n_results=1)
+        return results[0] if results else None
+
+
+if __name__ == "__main__":
+    retriever = AnimeRetriever()
+
+    # Test queries
+    print("=== Test 1: Basic Search ===")
+    results = retriever.search("dark psychological anime", n_results=5)
+    for anime in results:
+        print(
+            f"- {anime['title']} (score: {anime['score']}, relevance: {anime['relevance_score']:.3f})")
+
+    print("\n=== Test 2: Genre Filter ===")
+    results = retriever.search(
+        "high school", n_results=5, genre_filter="Comedy")
+    for anime in results:
+        print(f"- {anime['title']} ({anime['genres']})")
+
+    print("\n=== Test 3: Score Filter ===")
+    results = retriever.search("adventure", n_results=5, min_score=8.0)
+    for anime in results:
+        print(f"- {anime['title']} (score: {anime['score']})")
+
+    print("\n=== Test 4: Scored by Filter ===")
+    results = retriever.search("adventure", n_results=5, min_score=8.0)
+    for anime in results:
+        print(f"- {anime['title']} (score: {anime['score']}) (scored_by: {anime['scored_by']})")

try.py

@@ -0,0 +1,14 @@
+import requests
+from rich import print
+import json
+
+url = "https://api.jikan.moe/v4/anime"
+
+payload = {"id": {1}}
+
+response = requests.get(url=url, params=payload)
+
+response_json = response.json()
+
+with open("output.json", "w") as f:
+    json.dump(response_json, f, indent=4, ensure_ascii=False)

ui/gradio_app.py

@@ -0,0 +1,102 @@
+import gradio as gr
+import requests
+import os
+
+API_URL = os.getenv("API_URL", "http://127.0.0.1:8000")
+
+
+def get_recommendations(query, min_score, genre_filter):
+    """Call the fastapi backend"""
+    try:
+        payload = {
+            "query": query,
+            "n_results": 8
+        }
+
+        if min_score > 0:
+            payload["min_score"] = min_score
+
+        if genre_filter and genre_filter != None:
+            payload["genre_filter"] = genre_filter
+
+        response = requests.post(
+            f"{API_URL}/recommend",
+            json=payload,
+            timeout=30
+        )
+        response.raise_for_status()
+
+        result = response.json()
+        print(result["metadata"])
+        return result["recommendations"]
+    except requests.exceptions.RequestException as e:
+        return f"Error connecting to the API. Make sure FastAPI server is running. \nDetails: {str(e)}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+with gr.Blocks(title="Anime Recommender") as demo:
+    gr.Markdown("""
+    # Anime Recommendation System
+    
+    Powered by RAG(Retrieval-Augmented Generation)
+                
+    Ask for anime recommendations and get AI-powered suggestions!
+    """)
+    with gr.Row():
+        with gr.Column(scale=2):
+            query_input = gr.Textbox(
+                label="What are you looking for?",
+                placeholder="e.g., 'Anime similar to Death Note but lighter' or 'Romantic comedy set in high school'",
+                lines=3
+            )
+
+            with gr.Row():
+                min_score_slider = gr.Slider(
+                    minimum=0,
+                    maximum=10,
+                    value=0,
+                    step=0.5,
+                    label="Minimum Rating this animes should have (0 = no filter)"
+                )
+
+                genre_dropdown = gr.Dropdown(
+                    choices=["None", "Action", "Comedy", "Drama",
+                             "Romance", "Sci-Fi", "Fantasy", "Thriller"],
+                    value="None",
+                    label="Genre Filter (optional)"
+                )
+
+            submit_btn = gr.Button("Get Recommendations",
+                                   variant="primary", size="lg")
+
+        with gr.Column(scale=3):
+            output = gr.Markdown(label="Recommendations")
+
+    # Examples
+    gr.Examples(
+        examples=[
+            ["Anime similar to Death Note but lighter", 0, "None"],
+            ["Romantic comedy set in high school", 7.5, "Comedy"],
+            ["Dark psychological thriller", 8.0, "None"],
+            ["Action anime with epic fights", 7.0, "Action"],
+        ],
+        inputs=[query_input, min_score_slider, genre_dropdown],
+    )
+
+    # Connect button to function
+    submit_btn.click(
+        fn=get_recommendations,
+        inputs=[query_input, min_score_slider, genre_dropdown],
+        outputs=output
+    )
+
+# Launch
+if __name__ == "__main__":
+    print("Starting Gradio UI...")
+    print("Make sure FastAPI server is running at http://localhost:8000")
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True  # Set to True to get public URL
+    )