first production project

.gitattributes

@@ -0,0 +1,2 @@
+resources/game_readme.gif filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text

.github/workflows/main.yml

@@ -0,0 +1,20 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push https://HF_USERNAME:[email protected]/spaces/danielRamon/cluedo main

.gitignore

@@ -0,0 +1 @@
+*.pyc

generate_players.py

@@ -0,0 +1,56 @@
+from typing import List
+from langchain_ollama import OllamaLLM
+from langchain.output_parsers import PydanticOutputParser
+from langchain_core.prompts import PromptTemplate
+from langchain_core.pydantic_v1 import BaseModel, Field
+
+llm = OllamaLLM(model="gemma2", temperature=0.8)
+
+
+class Person(BaseModel):
+    name: str = Field(description="Person's name")
+    age: int = Field(description="Person's age")
+    nationality: str = Field(description="Person's nationality")
+    gender: str = Field(description="Person's gender")
+    description: str = Field(description="Person's description")
+    occupation: str = Field(description="Person's occupation")
+    known_languages: str = Field(
+        description="Person's known languages it could be one or more")
+
+
+class Witness(Person):
+    testimony: str = Field(description="Witness's testimony")
+
+
+class Suspect(Person):
+    guilty: bool = Field(description="Suspect's guilt")
+    background: str = Field(
+        description="Suspect's background during the crime")
+
+
+class Crime(BaseModel):
+    suspects: List[Suspect]
+    witnesses: List[Witness]
+    event: str = Field(
+        description="A long description with all the details about the crime with date, aproximetly time and place")
+    date: str = Field(description="Crime date")
+    location: str = Field(description="Crime location")
+    summary: str = Field(description="Brief description of the crime")
+    motive: str = Field(description="Motive of the crime")
+
+
+parser = PydanticOutputParser(pydantic_object=Crime)
+
+prompt = PromptTemplate(
+    template="Create a crime in {country} in all the text should be in the language of this country, and a list with {suspects} suspects and {witnesses} where only one of the suspects is guilty. \n {format_instructions}",
+    input_variables=["suspects", "witnesses"],
+    partial_variables={
+        "format_instructions": parser.get_format_instructions()},
+)
+
+
+def generate_crime(suspects, witnesses, country):
+    chain = prompt | llm | parser
+    output = chain.invoke(
+        {"suspects": suspects, "witnesses": witnesses, "country": country})
+    return output

readme.md

@@ -0,0 +1,61 @@
+## Cluedo
+
+### Detective Game with Streamlit and Ollama: Solve the Crime
+
+**Description:**
+
+Dive into an exciting world of mystery and crime-solving! This interactive game puts you in the shoes of a clever detective who must unravel a case. Interrogate suspects and witnesses, analyze clues, and use all your intelligence to discover the culprit.
+
+**Technologies:**
+
+* **Streamlit:** Streamlit's intuitive and user-friendly interface allows for a smooth and engaging gameplay experience.
+* **Ollama:** The large language model service Ollama, using the "Gemma2" model, generates cases and provides intelligent and realistic responses to the player's questions, creating an immersive interrogation experience.
+
+**Requirements:**
+
+* **Ollama:** The Ollama large language model service must be installed and running on its default port `11434`, and the `Gemma2` model should be downloaded.
+
+**How to Play:**
+1. Clone the repository:
+```bash
+git clone https://github.com/danielRamon/cluedo.git
+```
+2. Install the dependencies:
+```bash
+cd cluedo
+pip install -r requirements.txt
+```
+3. Start the game:
+```bash
+streamlit run streamlit_app.py
+```
+
+4. Play
+
+![Intro](./resources/intro_readme.gif)
+![Game](./resources/game_readme.gif)
+
+**Contributions:**
+
+Contributions are welcome! You can help improve the game in the following ways:
+
+* **AI Enhancement:** Explore ways to improve Ollama's ability to generate more natural and convincing responses, as well as using other LLM services.
+* **New Features:** Implement new features such as a scoring system, multiple difficulty levels, or the ability to save and load games.
+* **Create a Cloud Service:** You can deploy the game on a server so that others without technical knowledge can use it.
+
+**Project Structure:**
+
+* `streamlit_app.py`: The main file containing the game logic and the Streamlit user interface.
+* `generate_players.py`: Auxiliary code for creating stories and characters at the start of the game.
+* `resources`: Folder containing images for the end of the game.
+* `requirements.txt`: File listing the project's dependencies.
+
+**Notes:**
+
+This project is intended for self-learning purposes, so any constructive feedback is welcome.
+
+**Have fun solving crimes!**
+
+**Daniel Ramón Gallardo**
+
+**[LinkedIn](https://www.linkedin.com/in/daniel-ramon-gallardo/)**

requirements.txt

@@ -0,0 +1,5 @@
+langchain
+langchain-community
+langchain-ollama
+streamlit
+

streamlit_app.py

@@ -0,0 +1,156 @@
+from langchain_community.chat_message_histories import StreamlitChatMessageHistory
+from langchain_community.callbacks import StreamlitCallbackHandler
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.runnables.history import RunnableWithMessageHistory
+from langchain_ollama import ChatOllama
+
+
+import streamlit as st
+
+from generate_players import generate_crime
+
+# Set up webpage UI
+st.set_page_config(page_title="Detective", page_icon="🤖")
+
+# Initialize variables
+num_suspects = 2
+num_witnesses = 0
+country = "Spain"
+winner = False
+crime = None
+
+
+def start():
+    crime = generate_crime(num_suspects, num_witnesses, country)
+    st.session_state.crime = crime
+    st.session_state.clicked = True
+
+
+if 'clicked' not in st.session_state or st.session_state.clicked is not True:
+    st.session_state.resolved = False
+    st.session_state.clicked = False
+    st.write("<h1 style='text-align: center;'>🕵️‍♂️ Detective Game</h1>",
+             unsafe_allow_html=True)
+    num_suspects = st.slider(label="Suspects", min_value=2, max_value=10)
+    num_witnesses = st.slider(label="Witnesses", min_value=0, max_value=10)
+    country = st.text_input(label="Country", value=country)
+    st.button('New game', on_click=start)
+
+if st.session_state.clicked and not st.session_state.resolved:
+    st.sidebar.title("Notebook")
+    person_type = st.sidebar.selectbox(
+        "Persons", ["Suspect", "Witness"], placeholder="Choose persons")
+    if person_type == "Suspect":
+
+        all_suspects = [
+            suspect.name for suspect in st.session_state.crime.suspects]
+        my_person = st.sidebar.selectbox(
+            "Suspect", all_suspects, placeholder="Choose your suspect")
+        suspect_current = st.session_state.crime.suspects[all_suspects.index(
+            my_person)]
+        st.write(f"<h1 style='text-align: center;'>	🧐 {person_type}: {suspect_current.name}</h1>",
+                 unsafe_allow_html=True)
+        st.sidebar.markdown(f"""
+                        Age: {str(suspect_current.age)}\n
+                        Nationality: {suspect_current.nationality}\n
+                        Gender: {suspect_current.gender}\n
+                        Occupation: {suspect_current.occupation}\n
+                        Description: {suspect_current.description}\n
+                        """, )
+        if st.sidebar.button("Accuse"):
+            st.session_state.resolved = True
+            if suspect_current.guilty:
+                st.balloons()
+                winner = True
+                st.rerun()
+
+    elif person_type == "Witness":
+        all_witnesses = [
+            witness.name for witness in st.session_state.crime.witnesses]
+        my_person = st.sidebar.selectbox(
+            "Witness", all_witnesses, placeholder="Choose your witness")
+        suspect_current = st.session_state.crime.witnesses[all_witnesses.index(
+            my_person)]
+        st.write(f"<h1 style='text-align: center;'>👀 {person_type}: {suspect_current.name}</h1>",
+                 unsafe_allow_html=True)
+    # Set up memory
+    st.session_state.crime.event
+    msgs = StreamlitChatMessageHistory(key=my_person)
+    if len(msgs.messages) == 0:
+        msgs.add_ai_message("...")
+
+    system = """
+    You are a detective game where there are several characters and only one of them is the real culprit.
+    The user will have to talk to the different characters in the game to solve the case and find out who the real culprit is.
+    At this moment you are:
+    {person}
+
+    You should be very realistic, so if the user talk in any language that you sont' know tell that you don't understand and tell the languages you know but don't answer, in other case talk in the same language than the user.
+
+    You can only respond as if you were this person and never as an AI.
+
+    You cannot accuse the other suspect directly.
+
+    Only the suspects can lie at some point in other.
+    """
+    # Set up model
+    my_chat = ChatOllama(model="gemma2", temperature=0.5)
+
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", system),
+            MessagesPlaceholder(variable_name="history"),
+            ("human", "{question}"),
+        ]
+    )
+    chain = prompt | my_chat
+    chain_with_history = RunnableWithMessageHistory(
+        chain,
+        lambda session_id: msgs,
+        input_messages_key="question",
+        history_messages_key="history"
+    )
+
+    # Render current messages from StreamlitChatMessageHistory
+    for msg in msgs.messages:
+        st.chat_message(msg.type).write(msg.content)
+
+    # If user inputs a new prompt, generate and draw a new response
+    if prompt := st.chat_input():
+        st.chat_message("human").write(prompt)
+        # Note: new messages are saved to history automatically by Langchain during run
+
+        # agent response
+        st_cb = StreamlitCallbackHandler(st.container())
+        # print(suspect_current)
+        response = chain_with_history.invoke(
+            {"question": prompt, "person": suspect_current}, {"configurable": {"session_id": "any"}, "callbacks": [st_cb]})
+        st.chat_message("ai").write(response.content)
+elif st.session_state.resolved:
+    culprit = [
+        suspect for suspect in st.session_state.crime.suspects if suspect.guilty][0]
+    if winner:
+        multi = f'''**YOU WIN**
+
+
+            The culprit was: {culprit.name}
+
+
+            Reason: {culprit.background}
+        '''
+        st.markdown(multi,
+                    unsafe_allow_html=True)
+        st.image("resources/winner.webp")
+    else:
+        multi = f'''**YOU WIN (refresh to play again)**
+            The culprit was: {culprit.name}
+            Reason: {culprit.background}
+        '''
+        st.markdown(
+            f"""
+            **YOU FAILED (refresh to try again)**
+            The culprit: {culprit.name}
+            Reason: {culprit.background}
+            """,
+            unsafe_allow_html=True)
+        st.image("resources/looser.webp")