Added necessary files

.gitignore

@@ -0,0 +1,50 @@
+# These are some examples of commonly ignored file patterns.
+# You should customize this list as applicable to your project.
+# Learn more about .gitignore:
+#     https://www.atlassian.com/git/tutorials/saving-changes/gitignore
+
+# Node artifact files
+node_modules/
+dist/
+
+# Compiled Java class files
+*.class
+
+# Compiled Python bytecode
+*.py[cod]
+
+# Log files
+*.log
+
+# Package files
+*.jar
+
+# Maven
+target/
+dist/
+
+# JetBrains IDE
+.idea/
+
+# Unit test reports
+TEST*.xml
+
+# Generated by MacOS
+.DS_Store
+
+# Generated by Windows
+Thumbs.db
+
+# Applications
+*.app
+*.exe
+*.war
+
+# Large media files
+*.mp4
+*.tiff
+*.avi
+*.flv
+*.mov
+*.wmv
+.env

app.py

@@ -0,0 +1,102 @@
+import ast
+import requests
+import json
+import gradio as gr
+from models import *
+from pydantic import BaseModel, Field
+from workflow import app_graph
+from langchain.output_parsers import PydanticOutputParser
+from existing_solution import *
+
+class RouterResponse_1(BaseModel):
+    route :list[str]= Field(description=("A list of keys relevant to the user's query"))
+
+class SummaryResponse_1(BaseModel):
+    information: str=Field(description=("Condensed information based on the context provided"))
+    
+route_op_1=PydanticOutputParser(pydantic_object=RouterResponse_1)
+summary_op_1=PydanticOutputParser(pydantic_object=SummaryResponse_1)
+
+async def solution_langchain(query,prev_msgs,json_data):
+
+    response=await router_chain_1.ainvoke({"query":query,"previous_messages":prev_msgs,"format_instructions":route_op_1.get_format_instructions()})
+    routes=route_op_1.parse(response.content).route
+    print(routes)
+    if len(routes)!=0:
+        result = {key: json_data[key] for key in routes}
+        print(result)
+        response= await summary_chain_1.ainvoke({"query":query,"data":json.dumps(result),"previous_messages":prev_msgs,
+                                "format_instructions":summary_op_1.get_format_instructions()})
+        return summary_op_1.parse(response.content).information
+    else: return "Nothing"
+
+async def process_inputs(input_string,uploaded_file):
+
+    if uploaded_file is not None:
+        try:
+            with open(uploaded_file) as f:
+                file_content = json.load(f)
+        except Exception as e:
+            print(e)
+    else:
+        raise Exception("User data Needed")
+    input_list=[]
+    inputs = {"query": input_string,"previous_msgs":input_list,"ui_data":file_content,'information':[]}
+
+    extracted_1= await solution_langchain(query=input_string,prev_msgs=input_list,json_data=file_content)
+    final_state= await app_graph.ainvoke(inputs)
+    extracted_2=final_state['information']
+
+    url = os.getenv("PERSONALITY_URL") + "/chat"
+    message_1 = RESPONSE_PROMPT.format(query=input_string, user_information=extracted_1)
+    payload_1 = {
+        "message": message_1,
+        "personality": 'humanish'
+    }
+
+    response_1 = requests.post(url, json=payload_1)
+    response_1.raise_for_status()
+
+    url = os.getenv("PERSONALITY_URL") + "/chat"
+    message_2= RESPONSE_PROMPT.format(query=input_string, user_information=extracted_2)
+    payload_2 = {
+        "message": message_2,
+        "personality": 'humanish'
+    }
+
+    response_2 = requests.post(url, json=payload_2)
+    response_2.raise_for_status()
+
+    messages = [
+        ChatMessage(role="user", content=input_string),]
+
+    # Create a ChatRequest object
+    request = ChatRequest(
+        messages=messages,
+        user_preferences=file_content,
+        personality="humanish"
+    )
+
+    # Call the chat endpoint asynchronously
+    response_3= await chat_endpoint(request)
+    
+    
+    return response_1.json()["response"], response_2.json()["response"], response_3.response
+
+
+interface = gr.Interface(
+    fn=process_inputs,
+    inputs=[
+        gr.Textbox(label="Enter a string"),   
+        gr.File(label="Upload a JSON file", type="filepath")
+    ],
+    outputs=[
+        gr.Textbox(label="Solution 1 Langchain"),  
+        gr.Textbox(label="Solution 2 Langgraph"),
+        gr.Textbox(label="Existing Solution"),  
+    ],
+    title="Extracting Relevant UI",
+    description="Provide a query, previous messages and user_data. Make sure in user data these keys are present :['name', 'age', 'gender', 'preferences', 'personalInformation', 'relatedDemographics', 'history', 'painPoints', 'inefficienciesOrQualityOfLifeImprovements', 'additionalNotes']"
+)
+
+interface.launch()

env_template.txt

@@ -0,0 +1,2 @@
+OPEN_ROUTER_API_KEY=""
+PERSONALITY_URL=""

existing_solution.py

@@ -0,0 +1,210 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import httpx
+import requests
+import os
+from dotenv import load_dotenv
+from typing import List, Optional, Dict, Any
+import json
+
+
+load_dotenv()
+
+
+OPENROUTER_API_KEY = os.getenv("OPEN_ROUTER_API_KEY")
+PERSONALITY_URL = os.getenv("PERSONALITY_URL")
+app = FastAPI(title="ER5 v1.0.0")
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+    
+
+class ChatRequest(BaseModel):
+    messages: List[ChatMessage]=[]
+    temperature: Optional[float] = 0.7
+    max_tokens: Optional[int] = 1000
+    user_preferences: Optional[Dict[str, Any]] = None  
+    context: Optional[str] = ""
+    personality: Optional[str] = None
+
+class ChatResponse(BaseModel):
+    response: str
+    context: Optional[str] = None
+
+def build_system_message(preferences: Dict[str, Any]) -> dict:
+    """Create a system message based on schemaless user preferences"""
+    if not preferences:
+        return {"role": "system", "content": "You are a helpful assistant."}
+
+    preferences_str = "\n".join(
+        f"- {key}: {value if not isinstance(value, (list, dict)) else json.dumps(value)}" 
+        for key, value in preferences.items()
+    )
+
+    system_content = f"""You are a helpful assistant. Please consider these user preferences in your responses:
+
+        {preferences_str}
+        
+        Tailor your responses to align with these user preferences and characteristics."""
+
+    return {"role": "system", "content": system_content}
+
+def parse_context(context_str: str) -> List[dict]:
+    """Parse context string into messages list"""
+    if not context_str:
+        return []
+    try:
+        return json.loads(context_str)
+    except json.JSONDecodeError:
+        return []
+
+
+
+async def call_openrouter(messages: List[dict], temperature: float, max_tokens: int):
+    url = "https://openrouter.ai/api/v1/chat/completions"
+    
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    
+    payload = {
+        "model": "qwen/qwen-2.5-7b-instruct",
+        "messages": messages,
+        "temperature": temperature,
+        "max_tokens": max_tokens
+    }
+    
+    async with httpx.AsyncClient() as client:
+        response = await client.post(url, json=payload, headers=headers)
+        
+        if response.status_code != 200:
+            raise HTTPException(status_code=response.status_code, 
+                              detail=f"OpenRouter API error: {response.text}")
+        
+        return response.json()['choices'][0]['message']['content']
+# @app.post("/chat", response_model=ChatResponse)
+async def chat_endpoint(request: ChatRequest):
+    try:
+
+  
+        include_preferences = await should_include_preferences_llm(request.messages[-1].content)
+
+
+        messages = []
+
+        if include_preferences and request.user_preferences:
+            messages.append(build_system_message(request.user_preferences))
+
+
+        context_messages = parse_context(request.context)
+        messages.extend(context_messages)
+
+
+        messages.extend([{"role": msg.role, "content": msg.content} 
+                        for msg in request.messages])
+        
+
+        messages = messages[-10:]
+        
+        print(messages)
+
+        response = await decide_chat_api(
+            messages=messages,
+            temperature=request.temperature,
+            max_tokens=request.max_tokens,
+            personality=request.personality
+        )
+        
+        assistant_message = response
+        
+
+        context_messages = messages[1:] if include_preferences else messages  
+        context_messages.append({"role": "assistant", "content": assistant_message})
+        updated_context = json.dumps(context_messages[-10:])  
+        
+        return ChatResponse(response=assistant_message, context=updated_context)
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+async def should_include_preferences_llm(query: str) -> bool:
+    """
+    Use the LLM to decide if user preferences should be included based on the query.
+    """
+    url = "https://openrouter.ai/api/v1/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    
+
+    prompt = (
+        "You are an assistant that classifies user queries. "
+        "Given the query below, decide if user-specific context or preferences are relevant. "
+        "Respond with 'true' if any kind of personal context or preferences should be included in the response, "
+        "and 'false' otherwise.\n\n"
+        f"Query: {query}\n\n"
+        "Is this query related to personal context such as user preferences, lifestyle, habits, or any other factors "
+        "that could affect the response?"
+    )
+    
+    payload = {
+        "model": "qwen/qwen-2.5-7b-instruct",
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.0,  
+        "max_tokens": 5      
+    }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.post(url, json=payload, headers=headers)
+
+        if response.status_code != 200:
+            raise HTTPException(status_code=response.status_code, 
+                                detail=f"OpenRouter API error: {response.text}")
+
+      
+        llm_response = response.json()['choices'][0]['message']['content'].strip().lower()
+        return llm_response == "true" 
+
+async def call_personality_api(messages: List[dict], personality: str):
+    """
+    Call the external Personality API to handle chat completions.
+    """
+    url = "https://th4spvxpzqpmhb-8000.proxy.runpod.net/" + "/chat"
+    message_str = "\n".join([msg['content'] for msg in messages]) if messages else ""
+
+    payload = {
+        "message": message_str, 
+        "personality": personality  
+    }
+    payload = {
+    "message": message_str,
+    "personality": 'humanish'
+}
+
+    response = requests.post(url, json=payload)
+    if response.status_code != 200:
+        raise HTTPException(status_code=response.status_code, 
+                            detail=f"Personality API error: {response.text}")
+    
+    response_json = response.json()
+    if "response" in response_json:
+        return response_json["response"]
+    
+
+async def decide_chat_api(messages: List[dict], temperature: float, max_tokens: int,personality:str):
+    """
+    This function decides which API to call based on the presence of the PERSONALITY_URL environment variable.
+    """
+    if PERSONALITY_URL and PERSONALITY_URL.strip() and personality: 
+        print("yes")
+        return await call_personality_api(messages,personality)
+    else:
+       
+        return await call_openrouter(messages, temperature, max_tokens)
+
+# if __name__ == "__main__":
+#     import uvicorn
+#     uvicorn.run(app, host="0.0.0.0", port=8000)

models.py

@@ -0,0 +1,32 @@
+import os
+from pydantic import BaseModel, Field
+
+from dotenv import load_dotenv
+from prompts import *
+
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+
+load_dotenv()
+
+class RouterResponse_2(BaseModel):
+    route :list[str]= Field(description=("A list of keys relevant to the user's query"))
+class ExtractorResponse_2(BaseModel):
+    information: str=Field(description=("Condensed information based on the context provided"))
+
+llm = ChatOpenAI(model="openai/gpt-4o-mini",temperature=0.7,base_url="https://openrouter.ai/api/v1",
+api_key=os.getenv("OPEN_ROUTER_API_KEY"))
+
+router_prompt_1 = ChatPromptTemplate.from_messages([
+            ("system", "You are a routing assistant."),
+            ("user", router_instruction_prompt_1.format(query="{query}", previous_messages="{previous_messages}",
+                                               format_instructions="{format_instructions}"))])
+router_chain_1= router_prompt_1 | llm
+summary_prompt_1 = ChatPromptTemplate.from_messages([
+            ("system", "You are a Summarising assistant."),
+            ("user", summary_prompt_instructions_1.format(query="{query}", previous_messages="{previous_messages}",
+                                                        data="{data}",format_instructions="{format_instructions}"))])
+summary_chain_1 = summary_prompt_1 | llm
+
+router = router_instruction_prompt_2 | llm.with_structured_output(RouterResponse_2)
+extractor = extract_prompt_instructions_2 | llm.with_structured_output(ExtractorResponse_2)

prompts.py

@@ -0,0 +1,106 @@
+from langchain_core.prompts import PromptTemplate
+
+router_instruction_prompt_1="""
+You are tasked with analyzing user input to identify the most relevant keys from a dataset of user information. 
+Each key provides specific details about the user. 
+Your goal is to understand the query and conversation context to select the appropriate keys from which the user's data can help in providing accurate, personalised and actionable solutions.
+
+1. name: The user's full name.
+2. age: The user's age.
+3. gender: The user's gender.
+4. preferences: These are user's preferences.
+5. personalInformation: These are user's personal information details.
+6. relatedDemographics: Information pertaining to the user's geographic location and other demographic factors.
+7. history: A record of the user's recent activities, including search history, recent purchases, places visited, and other relevant actions or events.
+8. painPoints: The user's complaints, challenges, or issues they face.
+9. inefficienciesOrQualityOfLifeImprovements: Areas where the user seeks improvement, along with potential solutions to increase efficiency or enhance their quality of life.
+10. additionalNotes: Any extra information that might be relevant or helpful about the user.
+
+Instructions:
+- Analyze the user’s query and previous message to understand its purpose, context, and specific needs.
+- Determine which keys (one or multiple) are most relevant to extract the required information to provide a comprehensive and actionable response.
+- If no additional information is needed or no relevant details are found, route to None.
+- Pay special attention to personalInformation if the user's financial situation or budget is relevant to the decision-making process.
+
+Query: 
+{query}
+
+Previous Messages:
+{previous_messages}
+
+Format Instructions:
+{format_instructions}
+"""
+
+summary_prompt_instructions_1="""
+Given the following JSON data,query and previous messages condense all the information into a summary that captures all the details that may be relevant to providing solutions for the user query.
+Include in the summary only those points that are relevant to the query or conversation context. If nothing was found, return ""
+Query: 
+{query}
+
+Previous Messages:
+{previous_messages}
+
+Json Data:
+{data}
+
+Format Instructions:
+{format_instructions}
+"""
+
+router_instruction_prompt_2=PromptTemplate.from_template("""
+You are tasked with analyzing user input to identify the most relevant keys from a dataset of user information. 
+Each key provides specific details about the user. 
+Your goal is to understand the query and conversation context to select the appropriate keys from which the user's data can help in providing accurate, personalised and actionable solutions.
+
+1. name: The user's full name.
+2. age: The user's age.
+3. gender: The user's gender.
+4. preferences: These are user's preferences.
+5. personalInformation: These are user's personal information details.
+6. relatedDemographics: Information pertaining to the user's geographic location and other demographic factors.
+7. history: A record of the user's recent activities, including search history, recent purchases, places visited, and other relevant actions or events.
+8. painPoints: The user's complaints, challenges, or issues they face.
+9. inefficienciesOrQualityOfLifeImprovements: Areas where the user seeks improvement, along with potential solutions to increase efficiency or enhance their quality of life.
+10. additionalNotes: Any extra information that might be relevant or helpful about the user.
+
+Instructions:
+- Analyze the user’s query and previous message to understand its purpose, context, and specific needs.
+- Determine which keys (one or multiple) are most relevant to extract the required information to provide a comprehensive, personalised and actionable response.
+- If no additional information is needed or no relevant details are found, route to None.
+- Pay special attention to personalInformation if the user's financial situation or budget is relevant to the decision-making process.
+
+Query: 
+{query}
+
+Previous Messages:
+{previous_messages}
+""")
+
+extract_prompt_instructions_2=PromptTemplate.from_template("""
+Given the following JSON data,query and previous messages extract the information that may be relevant to providing solutions for the user query.
+
+Instructions:
+- Include in the summary only those points that are relevant to the query or conversation context.
+- If nothing relevant was found, return "".
+- Do not provide anything in your own words.
+
+Query: 
+{query}
+
+Previous Messages:
+{previous_messages}
+
+Json Data:
+{data}
+
+""")
+
+RESPONSE_PROMPT="""You are helpful assistant, Based on the User information and the query provide a response accordingly.
+Do not Fabricate or provide false details
+User information:
+{user_information}
+
+Query:
+{query}
+"""

requirements.txt

@@ -0,0 +1,7 @@
+requests
+langchain
+langchain_openai
+langgraph
+gradio
+pydantic
+python-dotenv

user_data.json

@@ -0,0 +1,71 @@
+{
+    "name": "Sarah Thompson",
+    "age": 34,
+    "gender": "Female",
+    "preferences": {
+      "hobbies": ["Photography", "Hiking", "Yoga", "Cooking Italian cuisine", "Attending local art exhibitions"],
+      "interests": ["Environmental sustainability", "Technology trends", "Travel blogging", "Contemporary fiction literature"],
+      "favoriteColor": "Teal"
+    },
+    "personalInformation": {
+      "approximateIncomeLevel": 85000,
+      "spendingPower": "Moderate to high",
+      "location": "Seattle, Washington",
+      "personality": ["Extroverted", "Organized", "Environmentally conscious", "Tech-savvy"],
+      "relationshipStatus": "Single",
+      "job": "Professional Photographer",
+      "educationLevel": "Master's degree in Rocket Science"
+    },
+    "relatedDemographics": {
+      "groups": ["Member of a local photography club", "Active participant in a yoga studio community"],
+      "relatedInterests": [
+        "Individuals interested in photography often engage with graphic design and visual arts communities",
+        "Environmental enthusiasts frequently explore topics like sustainable living and eco-friendly products"
+      ]
+    },
+    "history": {
+      "recentSearches": [
+        "Best mirrorless cameras 2023",
+        "Yoga retreats in Costa Rica",
+        "Electric cars vs. hybrids",
+        "Sustainable fashion brands",
+        "Samsung Galaxy S35 Ultra pro max",
+        "Iphone 19 with telescopic camera"
+      ],
+      "pastPurchases": [
+        "Organic skincare products",
+        "Tickets to local music festivals"
+      ],
+      "restaurantsVisited": ["Vegan bistros", "Farm-to-table restaurants", "Authentic Italian eateries"],
+      "storesFrequented": ["Whole Foods Market", "REI", "Apple Store", "Local independent bookstores"],
+      "websitesAppsUsedFrequently": ["Instagram", "Pinterest", "TripAdvisor", "Amazon", "Headspace app"]
+    },
+    "painPoints": {
+      "complaints": [
+        "Difficulty finding stylish yet sustainable clothing options",
+        "Frustration with traffic congestion during daily commute",
+        "Challenges in balancing work commitments with personal life and hobbies"
+      ],
+      "problems": [
+        "Concerned about environmental impact but finds eco-friendly products often priced at a premium",
+        "Aspires to advance her career but lacks time to pursue additional certifications or education"
+      ]
+    },
+    "inefficienciesOrQualityOfLifeImprovements": {
+      "areasForImprovement": [
+        "Seeking affordable, sustainable products without compromising on style or quality",
+        "Looking for more efficient commuting options to reduce time spent in traffic",
+        "Interested in apps or services that aid in time management and enhance productivity"
+      ],
+      "potentialSolutions": [
+        "Subscription services offering sustainable fashion at discounted rates",
+        "Carpooling apps or electric scooter services for a quicker commute",
+        "Productivity tools that integrate work schedules with personal goals"
+      ]
+    },
+    "additionalNotes": {
+      "techEngagement": "Being tech-savvy, Sarah is an early adopter of new technologies and is likely to be interested in beta testing new apps or gadgets",
+      "environmentalAdvocacy": "Actively participates in community clean-up events and promotes sustainable practices within her workplace",
+      "socialMediaInfluence": "Has a modest following on Instagram where she shares photography and sustainability tips, making her a micro-influencer in those niches"
+    }
+  }

workflow.py

@@ -0,0 +1,37 @@
+import json
+from typing_extensions import TypedDict
+from models import extractor, router
+from langgraph.graph import StateGraph, START,END
+
+class PlanExecute(TypedDict):
+    ui_data:dict
+    query:str
+    previous_msgs:list
+    list_keys: list
+    information:list
+
+async def route_step(state: PlanExecute):
+    response = await router.ainvoke({"query":state["query"],"previous_messages":state["previous_msgs"]})
+    return {"list_keys":response.route}  
+
+async def extract_step(state: PlanExecute):
+    key=state['list_keys'][0]
+    response = await extractor.ainvoke({"query":state["query"],"data":json.dumps(state['ui_data'][key]),"previous_messages":state["previous_msgs"]})
+    state['list_keys'].pop(0)
+    if response.information!='':
+        state['information'].append(response.information)
+        print(state['information'])
+
+def should_end(state: PlanExecute):
+    if len(state["list_keys"])==0:
+        return END
+    else:
+        return "extract_step"
+    
+workflow = StateGraph(PlanExecute)
+workflow.add_node("route_step", route_step)
+workflow.add_node("extract_step", extract_step)
+workflow.add_edge(START, "route_step")
+workflow.add_conditional_edges("route_step",should_end,[END, "extract_step"])
+workflow.add_conditional_edges("extract_step",should_end,[END, "extract_step"])
+app_graph = workflow.compile()