Upload 13 files

.gitattributes

@@ -1,35 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+faiss_index/index.faiss filter=lfs diff=lfs merge=lfs -text
+resources/Guide-to-Litiaton-in-India.pdf filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY . /app
+
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        ca-certificates \
+        netbase \
+        && rm -rf /var/lib/apt/lists/*
+
+RUN pip3 install -r requirements.txt
+
+ARG GOOGLE_API_KEY1
+ENV GOOGLE_API_KEY=$GOOGLE_API_KEY1
+
+ARG LANGCHAIN_API_KEY1
+ENV LANGCHAIN_API_KEY=$LANGCHAIN_API_KEY1
+
+EXPOSE 8501
+
+ENTRYPOINT ["streamlit", "run"]
+
+CMD ["app.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rajarshi Roy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,10 +1,290 @@
----
-title: Legal Agent
-emoji: 🔥
-colorFrom: yellow
-colorTo: blue
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Legal Agent Codebase
+
+- [LinkedIn - Rajarshi Roy](https://www.linkedin.com/in/rajarshi-roy-learner/)
+  
+- [Github - Rajarshi Roy](https://github.com/Rajarshi12321/)
+
+- [Medium - Rajarshi Roy](https://medium.com/@rajarshiroy.machinelearning)
+  
+- [Kaggle - Rajarshi Roy](https://www.kaggle.com/rajarshiroy0123/)
+- [Mail - Rajarshi Roy](mailto:royrajarshi0123@gmail.com)
+- [Personal-Website - Rajarshi Roy](https://rajarshi12321.github.io/rajarshi_portfolio/)
+
+
+## Table of Contents
+
+- [Legal Agent Codebase](#legal-agent-codebase)
+  - [Table of Contents](#table-of-contents)
+- [(DEMO README)](#demo-readme)
+  - [About The Project](#about-the-project)
+  - [Functionality](#functionality)
+  - [Code Structure](#code-structure)
+  - [Dependencies](#dependencies)
+  - [Working with the code](#working-with-the-code)
+  - [Deploying the project from your side (In AWS)](#deploying-the-project-from-your-side-in-aws)
+  - [Contributing](#contributing)
+  - [Contact](#contact)
+  - [License](#license)
+
+# (DEMO README)
+
+## About The Project
+
+This projects aim to implements a sophisticated document retrieval and question answering system using LangChain, leveraging Google's Gemini-1.5-flash language model and a FAISS vector database.  The system is designed to handle legal queries, providing comprehensive and accurate answers by combining information retrieval from a local knowledge base with web search capabilities when necessary.
+
+## Functionality
+
+The system follows a multi-stage workflow:
+
+1. **Query Input:** The user provides a query (e.g., a legal question).
+
+2. **FAISS Retrieval:** The query is embedded using Google Generative AI embeddings, and the FAISS index (a local vector database) is queried to retrieve the most relevant documents.
+
+3. **Grounded Response Generation:** A `DocSummarizerPipeline` summarizes the retrieved documents, focusing on the user's query.  This summary attempts to directly answer the question using only the retrieved documents.
+
+4. **Response Evaluation:** An `IntermediateStateResponseEvaluator` assesses the quality and completeness of the generated response.  This evaluation uses the Gemini model to determine if the response sufficiently answers the query.
+
+5. **Web Search (Conditional):** If the generated response is deemed insufficient, a `WebSearchAgent` performs a web search using DuckDuckGo to gather additional information.  The results are then incorporated into the final response.
+
+6. **Response Output:** The final answer, either from the document summary or the combined document/web search result, is returned to the user.
+  
+
+## Code Structure
+
+The code is organized into several classes and functions:
+
+* **`FaissRetriever`:** Loads and interacts with the FAISS index, retrieving relevant documents based on a query.
+
+* **`DocSummarizerPipeline`:** Summarizes retrieved documents using the Gemini model, generating a concise answer focused on the user's query.  It uses a carefully crafted prompt to ensure the response is structured and informative.
+
+* **`WebSearchAgent`:** Performs web searches using DuckDuckGo and integrates the results into the response.
+
+* **`IntermediateStateResponseEvaluator`:** Evaluates the quality of the generated response using the Gemini model, determining if additional information is needed.
+
+* **`State` (TypedDict):** Defines the data structure for passing information between stages of the workflow.
+
+* **Workflow Functions (`faiss_content_retriever`, `grounded_response`, `response_judge`, `web_response`):** These functions represent individual nodes in the LangGraph workflow.
+
+* **`StateGraph`:** Defines the workflow using LangGraph, managing the flow of data between the different stages.  Conditional logic is implemented to determine whether a web search is necessary.
+
+* **`run_user_query`:** The main function that takes a user query and processes it through the LangGraph workflow.
+<div align="center">
+Agent Workflow:
+
+![alt text](assets/agent_workflow.png)
+</div>
+
+## Dependencies
+
+The code relies on several libraries:
+
+* `langgraph`
+* `langchain-core`
+* `langchain-google-genai`
+* `IPython`
+* `dotenv`
+* `google.generativeai`
+* `langchain.chains.question_answering`
+* `langchain.prompts`
+* `langchain.vectorstores`
+* `langchain_community.tools`
+* `langchain.agents`
+
+
+
+## Working with the code
+
+
+I have commented most of the neccesary information in the respective files.
+
+To run this project locally, please follow these steps:-
+
+1. Clone the repository:
+
+   ```shell
+   git clone https://github.com/Rajarshi12321/legal-agent.git
+   ```
+
+
+2. **Create a Virtual Environment** (Optional but recommended)
+  It's a good practice to create a virtual environment to manage project dependencies. Run the following command:
+     ```shell
+     conda create -p <Environment_Name> python==<python version> -y
+     ```
+     Example:
+     ```shell
+     conda create -p venv python=3.9 -y 
+     ```
+    Note:
+    - It is important to use python=3.9 or above for proper use of Langchain or else you would get unexpecterd errors
+
+
+3. **Activate the Virtual Environment** (Optional)
+   Activate the virtual environment based on your operating system:
+      ```shell
+      conda activate <Environment_Name>/
+      ```
+      Example:
+     ```shell
+     conda activate venv/
+     ```
+
+4. **Install Dependencies**
+  
+   - Run the following command to install project dependencies:
+     ```
+     pip install -r requirements.txt
+     ```
+
+   Ensure you have Python installed on your system (Python 3.9 or higher is recommended).<br />
+   Once the dependencies are installed, you're ready to use the project.
+
+5. Create a .env file in the root directory and add your Gemini and Langchain credentials as follows:
+    ```shell  
+    GOOGLE_API_KEY = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+    ```
+
+
+6. Run the Flask app: Execute the following code in your terminal.
+   ```shell  
+   chainlit run app.py 
+   ```
+   
+
+6. Access the app: Open your web browser and navigate to http://localhost:8000/ to use the House Price Prediction and Property Recommendation app.
+
+## Deploying the project from your side (In AWS)
+
+I have already made a github actions file in `.github\workflows\main.yaml`
+To use it you need to the following prerequisites:
+
+1. Make a IAM Role from your aws account
+- 1. Login to AWS console.
+
+- 2. Create IAM user for deployment
+
+	#with specific access
+
+	1. EC2 access : It is virtual machine
+
+	2. ECR: Elastic Container registry to save your docker image in aws
+
+
+	#Policy: (You need to select these policies when building the user)
+
+	1. AmazonEC2ContainerRegistryFullAccess
+
+	2. AmazonEC2FullAccess
+
+2. Building the full infrastructure using Terraform </br></br>
+  1st you need to configure your aws account using the created IAM role by the command `aws configure` so that terraform can know which account to use </br></br>
+  NOTE: If you don't want to use terraform for building infrastructure you can also build this manually from aws console:</br>
+  For reference watch this video from `3:47:20` time frame : [Youtube link](https://www.youtube.com/watch?v=86BKEv0X2xU)</br></br>
+  Get to the terraform directory: `infrastructure\terraform` and execute the following commands:
+  </br></br>
+  Initializing Terraform
+    ```shell  
+    terraform init 
+    ```
+    Forming a plan according the described infrastructure
+    ```shell  
+    terraform plan 
+    ```
+    Applying the planned infrastructure to build necessary resources
+    ```shell  
+    terraform apply -auto-approve
+    ```
+
+    </br></br>
+3. After this you Need to configure your EC2 instance to install Docker:
+</br>Run The Following commands:
+    ```shell  
+    sudo apt-get update -y
+
+    sudo apt-get upgrade
+      
+
+    curl -fsSL https://get.docker.com -o get-docker.sh
+
+    sudo sh get-docker.sh
+
+    sudo usermod -aG docker ubuntu
+
+    newgrp docker
+   ```
+4. After this you need to configure the self-runner for github actions to actually deploy it to EC2 instance:
+  </br></br>
+  Check out the [Youtube vidoe](https://www.youtube.com/watch?v=86BKEv0X2xU) for reference from 3:54:38 time frame
+  </br></br>
+  The commands for settinng up self-hosted runner will be like: </br></br>
+  (NOTE: Do use the commands from your actions runner, the below commands are just for your reference)
+
+    ```shell  
+    mkdir actions-runner && cd actions-runner
+
+    curl -o actions-runner-linux-x64-2.316.1.tar.gz -L https://github.com/actions/runner/releases/download/v2.316.1/actions-runner-linux-x64-2.316.1.tar.gz
+
+
+    echo "d62de2400eeeacd195db91e2ff011bfb646cd5d85545e81d8f78c436183e09a8  actions-runner-linux-x64-2.316.1.tar.gz" | shasum -a 256 -c
+
+
+    tar xzf ./actions-runner-linux-x64-2.316.1.tar.gz
+
+    ./config.sh --url https://github.com/Rajarshi12321/main_app_deploy --token AWSY7XQOYHXWPQKGRAEQWRDGJD2GS
+
+    ./run.sh
+
+    ```
+
+   name the runner as : `self-hosted`
+
+1. Follow the Following [youtube video](https://www.youtube.com/watch?v=86BKEv0X2xU) from `3:57:14` time frame to know which secret Key and Value to add to your github actions secrets. Additionlly you have to add the `GOOGLE_API_KEY` in the secrets to with same key name as used in `.env` and their api keys as the values.
+
+2. Finally after doing all this you can run you github actions smoothly which is run by the instructions of `.github\workflows\main.yaml`
+   </br></br>
+  **Description: About the deployment by main.yaml**
+
+	1. Build docker image of the source code
+
+	2. Push your docker image to ECR
+
+	3. Launch Your EC2 
+
+	4. Pull Your image from ECR in EC2
+
+	5. Lauch your docker image in EC2
+
+
+  Now making any changes in any file except the readme.md file and assets folder (which contains images for readme)  will trigger the github action CI/CD pipeline for development.
+
+  NOTE: Do keep an eye on the state of the `self-hosted` runner, if its `idle` or `offline` then fix the condition my connecting to ec2 instance and run the `run.sh` file by:
+
+  ```shell
+  cd actions-runner
+
+  ./run.sh
+  ```
+
+
+
+## Contributing
+I welcome contributions to improve the functionality and performance of the app. If you'd like to contribute, please follow these guidelines:
+
+1. Fork the repository and create a new branch for your feature or bug fix.
+
+2. Make your changes and ensure that the code is well-documented.
+
+3. Test your changes thoroughly to maintain app reliability.
+
+4. Create a pull request, detailing the purpose and changes made in your contribution.
+
+## Contact
+
+Rajarshi Roy - [[email protected]](mailto:[email protected])
+
+
+
+## License
+This project is licensed under the MIT License. Feel free to modify and distribute it as per the terms of the license.
+
+I hope this README provides you with the necessary information to get started with the road to Generative AI with Google Gemini and Langchain.

app copy.py

@@ -0,0 +1,42 @@
+import streamlit as st
+from legal_agent.components.full_workflow import run_user_query
+
+# Initialize session state for conversation history
+if "conversation" not in st.session_state:
+    st.session_state.conversation = []
+
+st.title("Legal Agent Chat App")
+
+
+# Display conversation history
+def display_conversation():
+    for chat in st.session_state.conversation:
+        if chat["role"] == "user":
+            st.markdown(f"**User:** {chat['content']}")
+        else:
+            st.markdown(f"**Legal Agent:** {chat['content']}")
+
+
+display_conversation()
+
+# Input area for new query
+user_input = st.text_input("Enter your legal query:")
+
+if st.button("Send"):
+    if user_input.strip():
+        # Append user message to conversation
+        st.session_state.conversation.append({"role": "user", "content": user_input})
+
+        # Run the legal agent query workflow
+        result = run_user_query(user_input)
+        agent_response = result.get("response", "No response received.")
+
+        # Append agent response to conversation
+        st.session_state.conversation.append(
+            {"role": "assistant", "content": agent_response}
+        )
+
+        # Clear the text input by rerunning the app
+        st.experimental_rerun()
+    else:
+        st.error("Please enter a valid query.")

app.py

@@ -0,0 +1,48 @@
+import chainlit as cl
+from legal_agent.components.full_workflow import run_user_query
+
+# from QA_app.components.data_querying import user_query
+import chainlit as cl
+
+# user_query
+
+
+async def user_query_func(user_question):
+    response = run_user_query(user_question)
+    # Replace this with your actual logic for processing the user query
+    # It could involve interacting with an LLM, searching web documents, etc.
+    # For illustration purposes, let's just return a simple response
+    return response
+
+
+@cl.on_chat_start
+def start():
+    # user_query
+
+    print("Chat started!")
+
+
+@cl.on_message
+async def main(message: cl.Message):
+    # user_query
+    user_question = message.content
+    # response = user_query(user_question)
+    # response = await user_query_func("What happended to the birds")
+    response = await user_query_func(user_question)
+    print(user_question, "see")
+    # user_query = cl.make_async(user_query)
+
+    # await user_query("What happended to the birds")
+    # print(user_question, "see22222222")
+
+    # Use LangchainCallbackHandler to capture the final answer
+    # callback_handler = LangchainCallbackHandler(stream_final_answer=True)
+    # response = await cl.make_async(user_query)(user_question)
+    # response = await cl.make_async(user_query)(user_question)
+
+    # await message.reply(response)
+    await cl.Message(content=response["response"]).send()
+
+
+# # Run the Chainlit app
+# cl.run()

chainlit.md

@@ -0,0 +1,9 @@
+# Welcome to Game Recommendation APP! 🚀🤖
+
+**Objective: Let the Games Begin!**
+
+Welcome to the Game Recommendation Party! 🎉 Our mission is simple: to make gaming discovery as thrilling as playing the games themselves! With our vibrant and fun-loving Game Recommendation App, we're here to shake up the gaming world and inject a dose of excitement into every recommendation.
+
+Picture this: a magical realm where every gamer finds their perfect match, where the journey to discovering new games is filled with laughter, surprises, and endless joy. Our objective? To sprinkle a dash of fun into the gaming universe and ignite the spark of adventure in every player's heart.
+
+So, gear up, grab your controller, and get ready to embark on an epic quest through the world of gaming like never before. Let's turn every recommendation into a memorable adventure, where the only limit is your imagination! 🚀✨

demo_app.py

@@ -0,0 +1,311 @@
+# Importing Important libraries
+
+import streamlit as st
+from pathlib import Path
+
+import os
+
+import google.generativeai as genai
+
+from langchain_community.chat_message_histories.streamlit import (
+    StreamlitChatMessageHistory,
+)
+
+
+from datetime import datetime
+
+from langchain.memory.buffer import ConversationBufferMemory
+from langchain.schema.runnable import RunnableMap
+
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.prompts import MessagesPlaceholder
+
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.callbacks.tracers.langchain import wait_for_all_tracers
+
+import streamlit as st
+from streamlit_feedback import streamlit_feedback
+
+
+from langsmith import Client
+
+from langchain_core.tracers.context import collect_runs
+
+
+from dotenv import load_dotenv
+
+from langchain_community.vectorstores import FAISS
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+
+## Loading APIs
+
+load_dotenv()
+
+embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+
+genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+
+gemini_api_key = os.getenv("GOOGLE_API_KEY")
+
+
+os.environ["LANGCHAIN_PROJECT"] = "GAME RECOMMENDATION"  # Set your custom project name
+
+os.environ["LANGCHAIN_TRACING_V2"] = "true"
+os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGCHAIN_API_KEY")
+langchain_api_key = os.getenv("LANGCHAIN_API_KEY")
+
+# Update with your API URL if using a hosted instance of Langsmith.
+langchain_endpoint = os.environ["LANGCHAIN_ENDPOINT"] = (
+    "https://api.smith.langchain.com"
+)
+
+# Used LLM model
+
+
+# Adding an event loop
+import asyncio
+import aiohttp
+
+
+loop = asyncio.new_event_loop()
+asyncio.set_event_loop(loop)
+
+
+model = ChatGoogleGenerativeAI(
+    model="gemini-1.5-pro-latest",
+    api_key=gemini_api_key,
+    temperature=0.3,
+    convert_system_message_to_human=True,
+)
+
+
+# Configuring memory
+memory = ConversationBufferMemory(
+    chat_memory=StreamlitChatMessageHistory(key="langchain_messages"),
+    return_messages=True,
+    memory_key="chat_history",
+)
+
+
+# Load Vector DB
+new_db = FAISS.load_local(
+    "faiss_index", embeddings, allow_dangerous_deserialization=True
+)
+
+# Main retriever
+retriever = new_db.as_retriever()
+
+# Configuring Langsmith Client
+client = Client(api_url=langchain_endpoint, api_key=langchain_api_key)
+
+
+# Introducing try catch block in case you don't have a dataset with good feed back examples
+try:
+    # Getting best feedback examples to save in the memory context
+    examples = client.list_examples(
+        dataset_name="Feedbacks"
+    )  # Choose your dataset_name here
+
+    my_examples = []
+
+    for i in examples:
+        print(i.inputs)
+        print(i.outputs["output"]["content"])
+        print("\n\n--------\n\n")
+        my_examples.append(
+            (i.inputs["input"], {"output": i.outputs["output"]["content"]})
+        )
+except:
+    my_examples = []
+
+
+my_examples = my_examples[:2]
+
+# Configuring our runnablemap
+ingress = RunnableMap(
+    {
+        "input": lambda x: x["input"],
+        "chat_history": lambda x: memory.load_memory_variables(x)["chat_history"],
+        "time": lambda _: str(datetime.now()),
+        "context": lambda x: retriever.get_relevant_documents(x["input"]),
+        "examples": lambda x: my_examples,
+    }
+)
+
+# Making the prompt template
+prompt = ChatPromptTemplate.from_messages(
+    [
+        (
+            "system",
+            "Only discuss games. You are a GAME RECOMMENDATION system assistant. Be humble, greet users nicely, and answer their queries."
+            """
+            "Instructions": 
+            "Regardless of the input, always adhere to the context provided."
+            "You can only make conversations based on the provided context. If a response cannot be formed strictly using the context, politely say you dont have knowledge about that topic."
+            "Use the Context section to provide accurate answers, as if you knew this information innately."
+            "If unsure, state that you don't know."
+
+            "Context": {context}
+
+            "Examples of Human feedback": 
+            {examples},          
+            """,
+            # "system",
+            # "Only and Only talk about games, nothing else, your knowledge is constraint games"
+            # "You are a GAME RECOMMENDATION system assistant. You are humble AI. Greet the user nicely and answer their queries"
+            # """
+            #     Use the information from the Context section to provide accurate answers but act as if you knew this information innately.
+            #     If unsure, simply state that you don't know.
+            #     Context: {context}
+            #     Here are some impressive examples of Human feedback, Do your best to try to generate these type of answer format for the specific format of questions
+            #     The examples are listed below :
+            #     {examples}
+            #     Assistant:""",
+        ),
+        MessagesPlaceholder(variable_name="chat_history"),
+        ("human", "{input}"),
+    ]
+)
+
+llm = model
+
+# Our final chain
+chain = ingress | prompt | llm
+
+
+# Initialize State
+if "trace_link" not in st.session_state:
+    st.session_state.trace_link = None
+if "run_id" not in st.session_state:
+    st.session_state.run_id = None
+
+
+# Sidebar to give option for Clearing message history
+if st.sidebar.button("Clear message history"):
+    print("Clearing message history")
+    memory.clear()
+    st.session_state.trace_link = None
+    st.session_state.run_id = None
+
+
+# When we get response from the Chatbot, then only we can see this Trace link
+if st.session_state.trace_link:
+    st.sidebar.markdown(
+        f'<a href="{st.session_state.trace_link}" target="_blank"><button>Latest Trace: 🛠️</button></a>',
+        unsafe_allow_html=True,
+    )
+
+st.header("Hey Gamers, I am a Game Recommender 🤖", divider="rainbow")
+
+for msg in st.session_state.langchain_messages:
+    avatar = "🤖" if msg.type == "ai" else None
+    with st.chat_message(msg.type, avatar=avatar):
+        st.markdown(msg.content)
+
+
+# The main chatbot configuration to get desired out and create runs for Langsmith
+if prompt := st.chat_input(placeholder="Ask me a question!"):
+    st.chat_message("user").write(prompt)
+    with st.chat_message("assistant", avatar="🤖"):
+        message_placeholder = st.empty()
+        full_response = ""
+        print("in chat here")
+
+        # Getting the input
+        input_dict = {"input": prompt}
+
+        # Displaying the response from chatbot and collecting runs
+        with collect_runs() as cb:
+            for chunk in chain.stream(input_dict, config={"tags": ["Streamlit Chat"]}):
+                full_response += chunk.content
+                message_placeholder.markdown(full_response + "▌")
+        memory.save_context(input_dict, {"output": full_response})
+
+        # storing the run id in streamlit session
+        ## Since the runnable sequence would come after retriever I have chosen `1` instead on `0`
+        run_id = cb.traced_runs[1].id
+
+        st.session_state.run_id = run_id
+
+        wait_for_all_tracers()
+        # Requires langsmith >= 0.0.19
+
+        # Getting the Trace link
+        url = client.share_run(run_id)
+
+        st.session_state.trace_link = url
+
+        message_placeholder.markdown(full_response)
+
+# Checking if we have messages in chat
+has_chat_messages = len(st.session_state.get("langchain_messages", [])) > 0
+
+
+# Only show the feedback toggle if there are chat messages
+if has_chat_messages:
+    feedback_option = (
+        "faces" if st.toggle(label="`Thumbs` ⇄ `Faces`", value=False) else "thumbs"
+    )
+
+else:
+    pass
+
+if st.session_state.get("run_id"):
+    feedback = streamlit_feedback(
+        feedback_type=feedback_option,  # Use the selected feedback option
+        optional_text_label="[Optional] Please provide an explanation",  # Adding a label for optional text input
+        key=f"feedback_{st.session_state.run_id}",
+        align="flex-start",
+    )
+
+    # Define score mappings for both "thumbs" and "faces" feedback systems
+    score_mappings = {
+        "thumbs": {"👍": 1, "👎": 0},
+        "faces": {"😀": 1, "🙂": 0.75, "😐": 0.5, "🙁": 0.25, "😞": 0},
+    }
+
+    # Get the score mapping based on the selected feedback option
+    scores = score_mappings[feedback_option]
+
+    if feedback:
+        # Get the score from the selected feedback option's score mapping
+        score = scores.get(feedback["score"])
+
+        if score is not None:
+            # Formulate feedback type string incorporating the feedback option and score value
+            feedback_type_str = f"{feedback_option} {feedback['score']}"
+
+            # Record the feedback with the formulated feedback type string and optional comment
+            feedback_record = client.create_feedback(
+                st.session_state.run_id,
+                feedback_type_str,  # Updated feedback type
+                score=score,
+                comment=feedback.get("text"),
+            )
+            st.session_state.feedback = {
+                "feedback_id": str(feedback_record.id),
+                "score": score,
+            }
+
+            # # Incase you want to add this run with feedback to simultaneously add to a dataset
+            # run_id = st.session_state.get("run_id")
+            # selected_runs = client.list_runs(id=[run_id])
+
+            # for run in tqdm(selected_runs):
+
+            #     # print(run, "lets see")
+            #     print(run.inputs)
+            #     print(run.outputs)
+            #     print(run.extra)
+            #     print(run.feedback_stats)
+
+            #     client.create_examples(
+            #         inputs=[run.inputs],
+            #         outputs=[run.outputs],
+            #         feedback_stats=[run.feedback_stats],
+            #         dataset_id=<your-dataset-id>,
+            #     )
+
+        else:
+            st.warning("Invalid feedback score.")

demo_chaillit_app.py

@@ -0,0 +1,58 @@
+# from QA_app.components.data_querying import user_query
+from chainlit import on_chat_start, on_message, LangchainCallbackHandler
+import chainlit as cl
+from main_app_deploy.components.data_querying import my_query
+
+
+import os
+
+os.environ["LITERAL_API_KEY"] = os.getenv("LITERAL_API_KEY")
+
+os.environ["LANGCHAIN_PROJECT"] = "GAME RECOMMENDATION"
+
+os.environ["LANGCHAIN_TRACING_V2"] = "true"
+os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGCHAIN_API_KEY")
+
+
+# user_query
+
+
+async def user_query_func(user_question):
+    response = my_query(user_question)
+    # Replace this with your actual logic for processing the user query
+    # It could involve interacting with an LLM, searching web documents, etc.
+    # For illustration purposes, let's just return a simple response
+    return response
+
+
+@cl.on_chat_start
+def start():
+    # user_query
+
+    print("Chat started!")
+
+
+@cl.on_message
+async def main(message: cl.Message):
+    # user_query
+    user_question = message.content
+    # response = user_query(user_question)
+    # response = await user_query_func("What happended to the birds")
+    response = await user_query_func(user_question)
+    print(user_question, "see")
+    # user_query = cl.make_async(user_query)
+
+    # await user_query("What happended to the birds")
+    # print(user_question, "see22222222")
+
+    # Use LangchainCallbackHandler to capture the final answer
+    # callback_handler = LangchainCallbackHandler(stream_final_answer=True)
+    # response = await cl.make_async(user_query)(user_question)
+    # response = await cl.make_async(user_query)(user_question)
+
+    # await message.reply(response)
+    await cl.Message(content=response).send()
+
+
+# # Run the Chainlit app
+# cl.run()

demo_main.py

@@ -0,0 +1,11 @@
+from main_app_deploy.components.data_querying import my_query
+import os
+
+os.environ["LANGCHAIN_PROJECT"] = "GAME RECOMMENDATION"
+
+os.environ["LANGCHAIN_TRACING_V2"] = "true"
+os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGCHAIN_API_KEY")
+
+ans = my_query("can you reccomend me some fantasy games? about 2 games")
+
+print(ans)

requirements.txt

@@ -0,0 +1,31 @@
+beautifulsoup4
+chainlit
+chromadb
+duckduckgo_search==6.3.4
+fastapi
+faiss-cpu
+# flashrank[listwise]
+google-generativeai
+# google-play-scraper
+IPython
+ipykernel
+langchain==0.3.7
+langchain-community==0.3.7
+langchain_core
+langchain-docling
+langchain_google_genai==2.0.4
+# langchain_huggingface
+langgraph==0.2.48
+langserve
+langsmith
+pandas>=1.3.6
+pypdf
+PyPDF2
+python-dotenv
+regex
+streamlit
+# streamlit-feedback
+unstructured[pdf]==0.7.12
+# sse_starlette
+# uvicorn
+-e .

setup.py

@@ -0,0 +1,30 @@
+import setuptools
+
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
+
+__version__ = "0.0.0.1"
+
+REPO_NAME = "legal-agent"
+AUTHOR_USER_NAME = "Rajarshi12321"
+SRC_REPO = "legal_agent"
+AUTHOR_EMAIL = "[email protected]"
+
+
+setuptools.setup(
+    name=SRC_REPO,
+    version=__version__,
+    author=AUTHOR_USER_NAME,
+    author_email=AUTHOR_EMAIL,
+    description="A small python package for game recommendation using RAG model",
+    long_description=long_description,
+    long_description_content="text/markdown",
+    url=f"https://github.com/{AUTHOR_USER_NAME}/{REPO_NAME}",
+    project_urls={
+        "Bug Tracker": f"https://github.com/{AUTHOR_USER_NAME}/{REPO_NAME}/issues",
+    },
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src"),
+)

template.py

@@ -0,0 +1,35 @@
+import os
+from pathlib import Path
+import logging
+
+# logging string
+logging.basicConfig(level=logging.INFO, format="[%(asctime)s]: %(message)s:")
+
+project_name = "legal_agent"
+
+list_of_files = [
+    ".github/workflows/.gitkeep",
+    f"src/{project_name}/__init__.py",
+    f"src/{project_name}/components/__init__.py",
+    f"src/{project_name}/utils/__init__.py",
+    "requirements.txt",
+    "setup.py",
+    "research/trials.ipynb",
+]
+
+
+for filepath in list_of_files:
+    filepath = Path(filepath)
+    filedir, filename = os.path.split(filepath)
+
+    if filedir != "":
+        os.makedirs(filedir, exist_ok=True)
+        logging.info(f"Creating directory; {filedir} for the file: {filename}")
+
+    if (not os.path.exists(filepath)) or (os.path.getsize(filepath) == 0):
+        with open(filepath, "w") as f:
+            pass
+            logging.info(f"Creating empty file: {filepath}")
+
+    else:
+        logging.info(f"{filename} is already exists")