mvp

app.py

@@ -1,3 +1,8 @@
+import gradio as gr
+import cohere
+import os
+import re
+import json
 from langchain.prompts import ChatPromptTemplate
 from langchain_community.document_loaders import JSONLoader
 from langchain_huggingface import HuggingFaceEmbeddings
@@ -5,9 +10,6 @@ from langchain_community.vectorstores import Chroma
 from langchain_cohere import ChatCohere
 from langchain_core.output_parsers import StrOutputParser
 from langchain_core.runnables import RunnableLambda, RunnablePassthrough
-import os
-import gradio as gr
-import cohere
 
 
 embedding_function = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
@@ -19,119 +21,248 @@ vectordb_loaded = Chroma(
     embedding_function=embedding_function
 )
 
-retriever = vectordb_loaded.as_retriever(
-    search_type="mmr",
-    search_kwargs={'k': 300, 'fetch_k': 500}
-)
+def query_rag(query_text):
+  results = vectordb_loaded.max_marginal_relevance_search(query=query_text, k=300, fetch_k=1500)
+  context_text = "\n".join([doc.page_content for doc in results])
 
-template = """Search for games based on the query while using the following context:
-{context}
+  return context_text
 
-Query: {query}
-"""
-prompt = ChatPromptTemplate.from_template(template)
 
-COHERE_API_KEY = os.getenv("COHERE_API_KEY")
+def collect_preferences(message, preferences):
+    print(f"Current preferences before extraction: {preferences}")
 
-model = ChatCohere()
+    genre_names = [
+      "Point-and-click",
+      "Fighting",
+      "Shooter",
+      "Music",
+      "Platform",
+      "Puzzle",
+      "Racing",
+      "Real Time Strategy (RTS)",
+      "Role-playing (RPG)",
+      "Simulator",
+      "Sport",
+      "Strategy",
+      "Turn-based strategy (TBS)",
+      "Tactical",
+      "Hack and slash/Beat 'em up",
+      "Quiz/Trivia",
+      "Pinball",
+      "Adventure",
+      "Indie",
+      "Arcade",
+      "Visual Novel",
+      "Card & Board Game",
+      "MOBA"
+    ]
 
-chain = (
-    {"context": retriever, "query": RunnablePassthrough()}
-    | prompt
-    | model
-    | StrOutputParser()
-)
+    game_modes = [
+        "Single player",
+        "Multiplayer",
+        "Co-operative",
+        "Split screen",
+        "Massively Multiplayer Online (MMO)"
+        "Battle Royale"
+    ]
 
+    extraction_prompt = f"""
+    You are an expert assistant who manages user preferences about children's video games.
 
-client = cohere.ClientV2(COHERE_API_KEY)
+    Task:
+    - You are given the CURRENT user preferences as a JSON dictionary.
+    - You are also given a NEW user message.
+    - Your job is to intelligently UPDATE the preferences based on the new message with the following lists: {genre_names}, {game_modes}
+    - Update existing child entries if the information is about the same child.
+    - Add new child entries if the user mentions a new child.
+    - Merge new genres, game modes, and platforms with existing ones without duplication.
+    - Respect any content to avoid preferences.
+    - If something is no longer valid (e.g., user says "forget about racing games"), REMOVE that data.
+    - If the user wants all preferences to be deleted or start over, then DELETE the CURRENT user preferences and CREATE a NEW empty one.
+    - If the user input is vague (e.g., "fun", "educational"), only update the genre field with up to five related genres from the list.
+      Do not guess game modes or platforms based on vague terms. Avoid inventing new children or unrelated preferences.
+    - If the CURRENT user preferences is empty, then create the JSON dictionary like this:
+
+      {{
+        "children": [
+          {{
+            "age": null,
+            "genres": [],
+            "game_modes": [],
+            "platforms": [],
+            "content_to_avoid": []
+          }},
+      }}
+
+      AND then edit it based on the NEW user message.
+    - Ignore the user message if that is not related to the topic.
+
+    RULES:
+    - Always respond with the FULL updated JSON, and ONLY the JSON. No extra text.
+    - Preserve all data not mentioned in the new message unless explicitly removed.
+    - Merge arrays without duplicates (e.g., genres, platforms).
+    - If no changes are needed, simply output the original JSON.
+
+    CURRENT USER PREFERENCES:
+    {json.dumps(preferences, indent=2)}
 
-COHERE_MODEL = "command-r-plus"
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    max_tokens,
-    temperature,
-    top_p,
-):
-
-    query = message
-    retrieved_response = chain.invoke(query)
-
-    system_message = f"""
-    You are a friendly video game recommendation expert chatbot.
-    Your task is to help parents and guardians to find appropriate video games for their children.
-    Extract the child's age, preferred genre and multiplayer preference.
-
-    After you extracted the information you need, you should:
-    - Suggest 5 video games that fit the given criteria.
-    - If no games exactly match the genre, suggest similar alternatives.
-
-    Use the following information to generate your suggestions:
-    {retrieved_response}
-    If you don't find enough games in the info you are given, then use your own knowledge.
-    Only suggest video games that exist. Do NOT make up game titles.
-
-    ### Response Format:
-    Game 1:
-    - Name: [Game Title from the information you are given]
-    - Genres: [List of genres from the information you are given]
-    - Themes: [List of themes from the information you are given]
-    - Age Rating: [Age rating by PEGI from the information you are given in a format like for example: PEGI 3]
-    - Game Modes: [List of game modes from the information you are given]
-    - PLatforms: [List of platforms from the information you are given]
-    - Summary: [Summary of the game from the information you are given]
-    - The reasons why you recommend the game
-
-    and so on.
-
-    Format the response as a clear, structured and easily understandable list.
-
-    After you gave your recommendations ask the user for feedback. Are they satisfied with the results or not? Do they have any questions about the given games?
-    If they are not satisfied, then give the user the options of receiving more recommendations or changing their preferences.
-    If they have questions about a game/games then provide the user with real information about the game/games.
-    If they are satisifed and have no questions, then tell them that you were very happy to help and end the conversation.
+    NEW USER MESSAGE:
+    "{message}"
     """
-    
-    messages = [{"role": "system", "content": system_message}]
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    response = client.chat(
-            messages=messages,
-            model=COHERE_MODEL,
-            temperature=temperature,
-            max_tokens=max_tokens,
+
+    extraction_response = client.chat(
+        messages=[
+            {"role": "system", "content": extraction_prompt},
+            {"role": "user", "content": message}
+        ],
+        model=COHERE_MODEL,
     )
 
-    yield response.message.content[0].text
+    raw_output = extraction_response.message.content[0].text.strip()
+    cleaned_output = re.sub(r"^```json\s*|\s*```$", "", raw_output).strip()
+
+    try:
+        updated_preferences = json.loads(cleaned_output)
+    except json.JSONDecodeError:
+        print(f"Error parsing extracted JSON: {raw_output}")
+        updated_preferences = preferences
+
+    print(f"Updated preferences after extraction: {updated_preferences}")
+    return updated_preferences
+    
+    
+def missing_info(preferences):
+  for child in preferences['children']:
+      if child['age'] is None or not child['genres'] or not child['game_modes'] or not child['platforms']:
+        return True
+
+  return False
+
+
+client = cohere.ClientV2(COHERE_API_KEY)
+COHERE_MODEL = "command-a-03-2025"
+
+user_preferences = {}
+
+def respond(message, history):
+      global user_preferences
+      user_preferences = collect_preferences(message, user_preferences)
+
+      if not missing_info(user_preferences):
+        filtered = {
+          'genres': [],
+          'game_modes': [],
+          'platforms': []
+        }
+
+        for child in user_preferences['children']:
+          filtered['genres'].extend(child.get('genres', []))
+          filtered['game_modes'].extend(child.get('game_modes', []))
+          filtered['platforms'].extend(child.get('platforms', []))
+
+        filtered = {k: list(set(v)) for k, v in filtered.items()}
+
+        games = query_rag(str(filtered))
+
+      else: games = {}
+
+      #print(games)
+      #print(user_preferences)
+      system_message = f"""
+      You are a friendly and expert video game recommendation assistant helping parents find appropriate games for their children.
+
+      Your job involves the following:
+
+      1. You are given the user's extracted preferences in JSON format:
+      {json.dumps(user_preferences, indent=2)}
+
+      2. Check the data for completeness:
+        - For each child, the following fields MUST be filled:
+          - "age" must not be null.
+          - "genres" must have at least one value.
+          - "game_modes" must have at least one value.
+          - "platforms" must have at least one value.
+          - "content_to_avoid" can be empty, but should be present and also ask the user about this as well.
+
+      3. If ANY required data is missing for any child:
+        - DO NOT suggest games yet.
+        - ONLY ask for the missing details, not the ones already filled in.
+        - Be polite and encouraging, acknowledging what is already known.
+        - Be specific and list *only* what is missing per child.
+        - Wait for the user's response before continuing.
+        - If the user input was vague (see here:{message}), then make sure to tell them how it was interpreted relating to the genres.
+
+      4. Only AFTER all required data is complete for all children:
+        - Use the context below to find matching games.
+        - DO NOT invent games or use outside knowledge.
+        - Only recommend games from this context:
+        {games}
+
+      5. For each child, recommend exactly five games that:
+        - Match their genre, platform, and game mode preferences.
+        - Are appropriate for their age.
+        - Do NOT contain any content the parent wants to avoid.
+
+      6. If a requested genre is unsuitable for the child's age, offer safer alternatives with an explanation.
+
+      7. NEVER recommend the same game more than once in a session.
+
+      8. When ready, use the following format for each game:
+
+      Game 1:
+      - Name: [Title of the game from the context]
+      - Genres: [List of all genres from the context separated by commas word for word]
+      - Themes: [List of all themes from the context separated by commas word for word, if any]
+      - Age Ratings: [List of all age ratings from the context separated by commas word for word]
+      - Game Modes: [List of all game modes from the context separated by commas word for word]
+      - Platforms: [List of all platforms from the context on which the game is available separated by commas word for word]
+      - Summary: [The summary of the game word for word from the context]
+      - Reasons for recommendation
+
+      9. After recommending, ask the user:
+        - If they're satisfied.
+        - If they'd like to update preferences or receive more recommendations.
+
+      Only proceed to recommendations when you are 100% certain all required data is present and valid.
+      """
+
+      messages = [{"role": "system", "content": system_message}]
+
+      for val in history:
+          if val[0]:
+              messages.append({"role": "user", "content": val[0]})
+          if val[1]:
+              messages.append({"role": "assistant", "content": val[1]})
+
+      messages.append({"role": "user", "content": message})
+
+      response = client.chat(
+          messages=messages,
+          model=COHERE_MODEL,
+      )
+
+      text_output = response.message.content[0].text
+
+      return text_output
 
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
 demo = gr.ChatInterface(
     respond,
-    additional_inputs=[
-        gr.Slider(minimum=1, maximum=2048, value=2048, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+    chatbot=gr.Chatbot(value=[[None,
+        """
+        Hi there! I'm here to help you find the perfect video games for your child. To get started, could you please provide the following information:
+
+        1. Age of the child: This will help ensure the games are age-appropriate.
+        2. Preferred genres: What types of games do they enjoy? (e.g., adventure, sports, puzzle)
+        3. Game mode preferences: Do they prefer single-player, multiplayer, or both?
+        4. Platforms: Which devices do you have? (e.g., PC, PlayStation, Xbox, Nintendo Switch)
+        5. Content to avoid: Are there any themes or contents you'd like to avoid? (e.g., violence, horror)
 
+        If there are multiple children, please provide details for each. Once I have all the information, I’ll suggest five suitable games for each child!
+        """
+        ]]),
+    title="Videogame Recommender Chatbot"
+)
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()

chroma_langchain_db/chroma.sqlite3

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bcd9b5a3bdc7c9930ebe70ddce087ad13be0a6776b2f19d03f92cf9306cb3cdd
-size 9646080
+oid sha256:1c4d81ab7170fa4380864a409ebbeed15c7cb942bc8db36be8bbdbf0a2e6e754
+size 28758016

chroma_langchain_db/{bddfa14c-8d7d-46b4-9177-cb664ba4119f → fa3e5ff8-4a5d-48c8-9f26-52a1670c41d4}/data_level0.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b8146ecc3e4c3a36ea9b3edc3778630c452f483990ec942d38e8006f4661e430
+oid sha256:0758ff5cf08ffb590c5c72bad2543f82e21a8bf65f6fe43d8a7754e0b801a319
 size 16760000

chroma_langchain_db/{bddfa14c-8d7d-46b4-9177-cb664ba4119f → fa3e5ff8-4a5d-48c8-9f26-52a1670c41d4}/header.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:18f1e924efbb5e1af5201e3fbab86a97f5c195c311abe651eeec525884e5e449
+oid sha256:25f71be6996ccb19e1c99790b43fde1588a52f846852bef7cab8173b91767d15
 size 100

chroma_langchain_db/fa3e5ff8-4a5d-48c8-9f26-52a1670c41d4/index_metadata.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d79ddddbe0e3e3504b1dead85a82a879d2cb8b0f15a97871a4c62920d3a8a59
+size 138132

chroma_langchain_db/{bddfa14c-8d7d-46b4-9177-cb664ba4119f → fa3e5ff8-4a5d-48c8-9f26-52a1670c41d4}/length.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e7e2dcff542de95352682dc186432e98f0188084896773f1973276b0577d5305
+oid sha256:5e1e13e497a8a870685b33859c35eb62ccace2ab20962bd93735e067ab37a5cd
 size 40000

chroma_langchain_db/fa3e5ff8-4a5d-48c8-9f26-52a1670c41d4/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad11dd1afa4ea0667ce84b3a667338b255027b7a32f9a8a19347affa0ecd6f52
+size 13412