first commit

.gitignore

@@ -0,0 +1,12 @@
+# Python cache
+__pycache__/
+
+# Virtual Environment
+calibre-env/
+
+# Chroma DB databases
+chroma_db_*/
+
+# Other common Python files to ignore
+.env
+*.pyc

config.py

@@ -0,0 +1,69 @@
+from utils import get_file_data
+import os
+
+
+# user_journal = get_file_data("journal.txt")
+# example = get_file_data("example.json")
+
+
+
+# direcindirecprompt = f'''
+# I'll be giving you a journal entry written by a user. Your task is to extract out problems being faced by the user in the following format:
+# {{
+# "Overall Problem 1": ["Specific reason1 - reason why it was created", "Specific reason2  - reason why it was created"],
+# "Overall Problem 2": ["Specific reason1 - reason why it was created"],
+# }}
+# I'll give you an example how this overall - specific problem pair looks like. Here you'll see that the heading (single word is the overall problem), then we have the reasons why it was created
+# here is the overall - specific problem pair: {example}
+# Obviusly a single overall problem can have multiple specific reasons why it was created. Put it in the exact format as shown above.
+# Also, multiple overall problems can share a common specific reason why it was created. In that case, just repeat the specific reason under all of them.
+# Here is the user text you have to analyse: {user_journal}
+# Output strictly in the format given to you no extra symbols or words or anything
+
+'''
+
+# if os.path.getsize("overall_specific_problempair.json") != 0:
+#   user_problem = get_file_data("overall_specific_problempair.json")
+#     # print("File is empty")
+
+
+  # directdesc = f'''
+  # So i am giving you the iverall problems that are being faced by the user. Here it is: {user_problem.keys()}
+  # Now I want you to generate a 2-3 line summary/description for each of the problems. It shuold indicate what effect it has on the user's body and mind.
+  # So basically I want to perform a cosine similarity between this description that you give and a task dataset that has multiple tasks and they have their own descriptions of what they are able to cure
+  # So, If you write a good description for each overall problem, then I can match it with the task dataset descriptions to find the best matching tasks for the user.
+  # Here are examples of what is present int the task dataset descriptions:
+  # "Nadi Shodhana (Alternate Nostril Breathing)": {{
+  #           "Stress": [
+  #             "Balances left/right brain hemispheres for nervous system equilibrium",
+  #             "Reduces cortisol by 27% through symmetrical breathing patterns",
+  #             "Creates instant mental clarity during decision fatigue"
+  #           ],
+  #           "Emotions": [
+  #             "Harmonizes emotional extremes by balancing solar/moon energies",
+  #             "Resets emotional reactivity through prefrontal cortex activation",
+  #             "Integrates logical and intuitive aspects of awareness"
+  #           ],
+  #           }}
+  # "Bakasana (Crow Pose)": {{
+  #             "Focus": [
+  #               "Develops laser-like concentration to prevent falling",
+  #               "Trains mind-body coordination in challenging position",
+  #               "Builds mental discipline through fear management"
+  #             ],
+  #             "Strength": [
+  #               "Develops core and wrist strength simultaneously",
+  #               "Tones abdominal muscles through active engagement",
+  #               "Builds functional arm strength for daily activities"
+  #             ],
+  #             }}
+  # So, you see there is a certain way the descriptions are written for the task and hence you need to generate the descriptions for the overall problems in a similar way so that cosine similarity precisely extracts onyl those tasks which are highly relevant to the overall problems being faced by the user.
+  # Also, follow the following format strictly:
+  # {{
+  # "Overall Problem 1": ["Description"]
+  # "Overall Problem 2": ["Description"]
+  # }}
+
+  # Remember to output not anything else what is said, also don't use veyr veyr complicated words. You can use some technical words but keep it simple and precise otherwise if those words are present in the task dataset then cosine similaity will be very less.
+  # also, replace "Overall Problem 1" with the problem name for which description is being written
+  # '''

example.json

@@ -0,0 +1,7 @@
+{
+    "Axienty":["User is feeling that their might be no one to understand or console him","user recieved a mail from a boss or professor saying “We need to talk"],
+    "Sleepness":["User is having trouble falling asleep at night","User said that couldn't sleep till 4 am and then had an interview in the early morning"],
+    "Procrastination":["User mentioned that they keep scrolling social media instead of completing deadline tasks"],
+    "Depression":["User mentioned stopped feeling excited about hobbies, sports, games, or hanging out."]
+    
+}

journal.txt

@@ -0,0 +1,18 @@
+So i joined an American company. It was a beautiful experience when i was finally able to work exact office hours and where we were treated like adults and not kids.
+No shouting, no yelling during meeting. Politely giving us our tasks, and taking an update only after deadline. Even if deadline is missed, instead of arguing, they tried to find out why did it happen and what they can do to help reach it the next time. All the help was provided without ever having any issue with each other. Colleagues are great and helpful.
+Every morning i was eager to work and woke up with enthusiasm
+But this lasted only until they decided to introduce a mediatory between us.
+AN INDIAN MANAGER
+We all knew how indian tendency is regarrding work culture, and our fears came true.
+The manager now wanted to control all the things we did. On top of that he started doubting us whether we are slacking off work. So he asked us to timetrack all our activities while at home. Started delegating his own work to us which wasnt even in the job profile. Soon the politics started when he decided to involve top management even in low level discussion so that his views are enforced. On top of that all his mistakes that delay work are quitely not recorded on anything.
+Messaging us at odd times after office hours and expecting us to work late at night is very 'casual' and signs of dedicated employee. The attitude of 'toh kya hua' is affecting very negatively.
+I did not for a second ever imagined that such a wonderful experience of working in a great company could be destroyed by 1 person. The work culture that i left with previous company has now caught up to me again.
+This is one of the biggest reason i am trying to leave India and find a job elsewhere , where even if pay is low i'll be able to live peacefully.
+Four years. Three unicorn startups. Multiple cities. And yet, here I am, sitting at my desk, wondering why this part of corporate life feels like navigating a maze blindfolded. Let me vent—because maybe I’m not alone?
+“Hindi hai, bro? Cool, let’s switch.” Imagine walking into a meeting that starts with a polite “How’s your day?” in English, only for the next 30 minutes to dissolve into rapid-fire Hindi. Jokes fly, ideas bounce, and you’re just…nodding. Not because you agree, but because you’re lost. You’re South Indian, Northeast, or from a region where Hindi isn’t your mother tongue. You’ve tried learning it—really!—but fluency? The slang? The casual wit that makes everyone laugh? It’s like trying to catch smoke with your hands.
+The worst part? The bonding. Chai breaks, lunch tables, even Slack threads—suddenly, you’re the outsider in your own office. Colleagues bond over shared references, memes, and inside jokes you can’t decode. You smile awkwardly, laugh a beat too late. It’s not malice; it’s just…habit. But when promotions hinge on “culture fit,” how do you fit into a culture that feels linguistically gated?
+2. “No Smoke? No Drink? No Seat at the Table.” Here’s the other “unofficial rulebook”: smoke breaks = networking gold. Every hour, the balcony fills with folks puffing away, discussing projects, venting about managers, or just…chatting. You don’t smoke? Congrats on the healthy lungs! Now enjoy staring at your screen while career-critical conversations happen without you.
+And office parties? If you’re not clinking glasses, you’re a ghost. “Why aren’t you drinking?!” becomes the anthem of the night. Decline politely, and suddenly, you’re the “boring one.” The FOMO isn’t about the alcohol—it’s about the camaraderie that evaporates when you’re not “one of them.”
+So…Is It Just Me? I’m not judging anyone’s choices. Smoke if you want. Drink if you like. Speak whatever language feels like home. But when exclusion becomes the collateral damage of these habits, it’s exhausting. You start questioning: Is my career growth tied to my ability to chain-smoke or crack jokes in Hindi?
+To anyone else sitting silently in meetings, faking laughs, or skipping parties to avoid the peer pressure—I see you. This isn’t about “snowflake syndrome.” It’s about workplaces feeling like high school cliques, where your worth hinges on things that have nothing to do with your skills.
+I feel sick knowing how these cronies abuse the shit out of us, rob us from our money. CEO Narayan Murthy wants us to work for 70 hours per week but the dude himself can't see anything fucking straight, cross-eyed loser. We should just work for 10 hours per week max and call it a day. This 9-5 is making us depressed. We also need to stop breeding like cockroaches because at least, unlike humans, cockroaches can walk over themselves, but humans can't. I blame the system and schools such as City International School which looks like a fucking warehouse which you have to pay 89k rupees for annually, where's the infrastructure man? Nigerian schools have better infrastructure and better toilets which don't stink of piss. Also, school boards such as ICSE are to blame for this slave mentality. Also, when are we going to employ a 1 child policy? We should be having a king culture rather than a fucking slave culture which is glorified in this shit country. No wonder people are crippled nowadays. They are perpetually stressed. The average Indian man goes bald by 30 and grow a tummy like the laughing Buddha. Tax the rich CEOs and not the common man, why don't we Indians unionize and fight for our goddamn rights huh?

requirements.txt

@@ -0,0 +1,148 @@
+aiohappyeyeballs==2.6.1
+aiohttp==3.13.2
+aiosignal==1.4.0
+annotated-doc==0.0.4
+annotated-types==0.7.0
+annoy==1.17.3
+anyio==4.12.0
+asttokens==3.0.1
+attrs==25.4.0
+certifi==2025.11.12
+charset-normalizer==3.4.4
+click==8.3.1
+coloredlogs==15.0.1
+comm==0.2.3
+dataclasses-json==0.6.7
+debugpy==1.8.17
+decorator==5.2.1
+distlib==0.4.0
+distro==1.9.0
+dnspython==2.8.0
+dotenv==0.9.9
+executing==2.2.1
+faiss-cpu==1.13.1
+fastapi==0.124.2
+fastembed==0.6.0
+filelock==3.20.0
+filetype==1.2.0
+flatbuffers==25.9.23
+frozenlist==1.8.0
+fsspec==2025.12.0
+greenlet==3.3.0
+groq==0.37.1
+h11==0.16.0
+hf-xet==1.2.0
+httpcore==1.0.9
+httpx==0.28.1
+httpx-sse==0.4.3
+huggingface-hub==0.36.0
+humanfriendly==10.0
+idna==3.11
+ipykernel==7.1.0
+ipython==9.8.0
+ipython_pygments_lexers==1.1.1
+jedi==0.19.2
+Jinja2==3.1.6
+joblib==1.5.2
+jsonlines==4.0.0
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.25.1
+jsonschema-specifications==2025.9.1
+jupyter_client==8.6.3
+jupyter_core==5.9.1
+langchain==1.1.2
+langchain-classic==1.0.0
+langchain-community==0.4.1
+langchain-core==1.1.1
+langchain-groq==1.1.0
+langchain-nomic==1.0.1
+langchain-nvidia-ai-endpoints==1.0.0
+langchain-text-splitters==1.0.0
+langgraph==1.0.4
+langgraph-checkpoint==3.0.1
+langgraph-prebuilt==1.0.5
+langgraph-sdk==0.2.14
+langsmith==0.4.56
+lark==1.3.1
+loguru==0.7.3
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+marshmallow==3.26.1
+matplotlib-inline==0.2.1
+mdurl==0.1.2
+mmh3==5.2.0
+mpmath==1.3.0
+multidict==6.7.0
+mypy_extensions==1.1.0
+nest-asyncio==1.6.0
+nomic==3.9.0
+numpy==2.3.5
+onnxruntime==1.23.2
+orjson==3.11.5
+ormsgpack==1.12.0
+packaging==25.0
+pandas==2.3.3
+parso==0.8.5
+perplexityai==0.22.0
+pexpect==4.9.0
+pillow==11.3.0
+platformdirs==4.5.1
+prompt_toolkit==3.0.52
+propcache==0.4.1
+protobuf==6.33.2
+psutil==7.1.3
+ptyprocess==0.7.0
+pure_eval==0.2.3
+py_rust_stemmers==0.1.5
+pyarrow==22.0.0
+pydantic==2.12.5
+pydantic-settings==2.12.0
+pydantic_core==2.41.5
+Pygments==2.19.2
+PyJWT==2.10.1
+pymongo==4.15.5
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.1
+pytz==2025.2
+PyYAML==6.0.3
+pyzmq==27.1.0
+referencing==0.37.0
+regex==2025.11.3
+requests==2.32.5
+requests-toolbelt==1.0.0
+rich==14.2.0
+rpds-py==0.30.0
+scikit-learn==1.8.0
+scipy==1.16.3
+shellingham==1.5.4
+simpleeval==1.0.3
+six==1.17.0
+sniffio==1.3.1
+SQLAlchemy==2.0.44
+stack-data==0.6.3
+starlette==0.50.0
+sympy==1.14.0
+tenacity==9.1.2
+threadpoolctl==3.6.0
+tiktoken==0.12.0
+tokenizers==0.22.1
+tornado==6.5.2
+tqdm==4.67.1
+traitlets==5.14.3
+typer==0.20.0
+typing-inspect==0.9.0
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2025.2
+u==1.0.4
+urllib3==2.6.0
+uuid_utils==0.12.0
+uvicorn==0.38.0
+virtualenv==20.35.4
+virtualenvwrapper-win==1.2.7
+watchdog==6.0.0
+wcwidth==0.2.14
+xxhash==3.6.0
+yarl==1.22.0
+zstandard==0.25.0

tp_final.py

@@ -0,0 +1,447 @@
+# from itertools import islice
+# import itertools
+# import json
+# import re
+# from groq import Groq
+# from config import direcindirecprompt
+# from utils import groq_calls,write_to_file, get_file_data, get_mongo_collection
+# from sklearn.feature_extraction.text import TfidfVectorizer
+# from sklearn.metrics.pairwise import cosine_similarity
+# import numpy as np
+# from datetime import datetime
+
+# '''
+# The architecture is like this
+
+# '''
+# collection = get_mongo_collection()
+
+# def main():
+#     # user_journal = get_file_data("journal.txt")
+#     # example = get_file_data("example.json")
+
+
+#     # prompt= direcindirecprompt
+#     direcindirecgroq_response = groq_calls(direcindirecprompt)
+#     # parsed_json = json.loads(direcindirecgroq_response)
+#     # print(parsed_json)
+#     # write_to_file("overall_specific_problempair.json",direcindirecgroq_response)
+
+#     guideprompt = f'''
+#     So, I am giving a set of direct-indirect problem pair, here it is: {direcindirecgroq_response}
+#     Now, these are some of the issues the user is facing in his daily life. Assume that you're a very skilled psychologist and help solve the problems faced
+#     by the users in their daily life by recommending them a set of guidelines of what they could follow or practice in their daily life to keep themselves calm
+#     These guidelines should not be very long, some short recommendations which can be followed even when the person is seated on his chair in office
+#     or any where else. Basically the guidelines should be accessible/doable any time.
+#     Give 1-2 guidelines for each of the problem that the user is facing as in the problem pair procided to you
+
+#     Here are some examples of how guidelines could look like
+#     -Take short breaks for deep breathing, walk in the present, and journal three things you're grateful for daily to shift perspective.
+#     -Dedicate even 10 minutes to a hobby or enjoyable activity to recharge. 
+#     -Reduce news consumption and screen time, especially before bed, to avoid overwhelm.
+
+#     Above are some examples only, but remember whatever you suggest should be relevant to the problems the user is facing
+#     Final output should be in JSON format only
+#     final output should start and end like this
+#     {{
+#         problem1:["Set dedicated focus blocks (e.g., 90‑min) and log only the block end to satisfy reporting.","Use a private tracker to note progress, then share a concise daily summary with the manager."]
+#     }} 
+#     '''
+
+#     guidegroq_response = groq_calls(guideprompt)
+#     # with open("test.json", "w") as f:
+#     #     f.write(guidegroq_response)
+
+
+
+
+#     with open("structured_output_updated.json","r") as f:
+#         task_dataset = json.load(f)
+        
+
+
+#     result = {}
+#     # task_dataset = test
+#     yogabranches = list(task_dataset["Yoga"]["branches"].keys())
+#     for branch in yogabranches: 
+#         if branch == "Asana":
+#             postures = list(task_dataset["Yoga"]["branches"][branch].keys())
+#             # print(postures)
+#             result[f"{branch}s"] = {}
+#             for posture in postures:
+#                 lst = list(task_dataset["Yoga"]["branches"][branch][posture].keys())
+#                 for pose in lst:
+#                     # # poses.append(task_dataset["Yoga"]["branches"][branch][posture][pose])
+#                     # print(task_dataset["Yoga"]["branches"][branch][posture][pose])
+#                     sliced_items = list(task_dataset["Yoga"]["branches"][branch][posture][pose].values())[:2]
+#                     result[f"{branch}s"][pose] = list(itertools.chain.from_iterable(sliced_items))
+#         else:
+#             postures = list(task_dataset["Yoga"]["branches"][branch].keys())
+#             # print(postures)
+#             result[f"{branch}s"] = {}
+#             for posture in postures:
+#                 lst = list(task_dataset["Yoga"]["branches"][branch][posture].values())[:2]
+#                 result[f"{branch}s"][posture] = list(itertools.chain.from_iterable(lst))
+
+#     # with open("overall_specific_problempair.json","r",encoding = "utf-8") as f:
+#     #     user_problem = json.load(f)
+    
+#     user_problem = json.loads(direcindirecgroq_response)
+
+#     cosineprompt = f'''
+#   So i am giving you the iverall problems that are being faced by the user. Here it is: {user_problem.keys()}
+#   Now I want you to generate a 2-3 line summary/description for each of the problems. It shuold indicate what effect it has on the user's body and mind.
+#   So basically I want to perform a cosine similarity between this description that you give and a task dataset that has multiple tasks and they have their own descriptions of what they are able to cure
+#   So, If you write a good description for each overall problem, then I can match it with the task dataset descriptions to find the best matching tasks for the user.
+#   Here are examples of what is present in the task dataset descriptions:
+#   "Nadi Shodhana (Alternate Nostril Breathing)": {{
+#             "Stress": [
+#               "Balances left/right brain hemispheres for nervous system equilibrium",
+#               "Reduces cortisol by 27% through symmetrical breathing patterns",
+#               "Creates instant mental clarity during decision fatigue"
+#             ],
+#             "Emotions": [
+#               "Harmonizes emotional extremes by balancing solar/moon energies",
+#               "Resets emotional reactivity through prefrontal cortex activation",
+#               "Integrates logical and intuitive aspects of awareness"
+#             ],
+#             }}
+#   "Bakasana (Crow Pose)": {{
+#               "Focus": [
+#                 "Develops laser-like concentration to prevent falling",
+#                 "Trains mind-body coordination in challenging position",
+#                 "Builds mental discipline through fear management"
+#               ],
+#               "Strength": [
+#                 "Develops core and wrist strength simultaneously",
+#                 "Tones abdominal muscles through active engagement",
+#                 "Builds functional arm strength for daily activities"
+#               ],
+#               }}
+#   So, you see there is a certain way the descriptions are written for the task and hence you need to generate the descriptions for the overall problems in a similar way so that cosine similarity precisely extracts onyl those tasks which are highly relevant to the overall problems being faced by the user.
+#   Also, follow the following format strictly:
+#   {{
+#   "Overall Problem 1": ["Description"]
+#   "Overall Problem 2": ["Description"]
+#   }}
+
+#   Remember to output not anything else what is said, also don't use very complicated words. You can use some technical words but keep it simple and precise otherwise if those words are present in the task dataset then cosine similaity will be very less.
+#   also, replace "Overall Problem 1" with the problem name for which description is being written
+#   '''
+    
+#     cosinegroq_response = groq_calls(cosineprompt)
+#     # with open("test.json","w") as f:
+#     #     f.write(cosinegroq_response)
+#     parsed_json = json.loads(cosinegroq_response)
+#     # write_to_file("overall_problemdesc.json",cosinegroq_response)
+
+#     user_problem = parsed_json
+#     user_problem_text = " ".join(sum(user_problem.values(), [])) 
+#     tasks = {}
+#     for branch in result.keys():
+#         for pose in result[branch].keys():
+#             documents = []
+#             # print(result[branch][pose])
+#             desc = ", ".join(result[branch][pose])
+#             # print(desc)
+#             documents.append(desc)
+#             documents.append(user_problem_text)
+            
+#             # documents[0] ='Micromanagement  scrutiny, raising heart rate and restlessness. leading to tight muscles and frequent headaches. Language barriers and frustration, making communication difficult. Shallow breathing and lowering confidence and increasing social anxiety. Social exclusion triggers. It reduces heart rate variability and raises cortisol, leaving the body stressed. Burnout produces persistent fatigue, headaches, and muscle aches. Focus and decision‑making suffer, while sleep quality drops and inflammation markers rise. Discrimination induces emotional distress and self‑doubt, making the mind hypervigilant and anxious. stressing the body.'
+#             vectorizer = TfidfVectorizer(stop_words='english')
+#             tfidf_matrix = vectorizer.fit_transform(documents)
+#             similarities = cosine_similarity(tfidf_matrix[-1], tfidf_matrix[:-1]).flatten()
+#             tasks[f"{branch}({pose})"]= similarities
+#             # print(f"{branch} --> ", f"{pose} --> ", similarities)
+    
+#     print(documents)
+#     sorted_tasks = dict(sorted(tasks.items(), key=lambda item: item[1], reverse=True))
+#     print(list(sorted_tasks.items())[:5])
+
+#     username = "sameer" #in production extract the username 
+
+#     if collection is not None:
+#             chat_document = {
+#                 "user_id": username,
+#                 "timestamp": datetime.now(),
+#                 "problemdesc": direcindirecgroq_response,
+#                 "guidelines":guidegroq_response,
+#                 "tasks": list(sorted_tasks.keys())[:5]
+
+#             }
+            
+#             try:
+#                 collection.insert_one(chat_document)
+#                 print("Saved to DB")
+#             except Exception as e:
+#                 print(f"Failed to save to DB: {e}")
+
+# if __name__ == "__main__":
+#     main()
+
+
+
+
+
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+from itertools import islice
+import itertools
+import json
+import re
+from datetime import datetime
+
+# ML and Math imports
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import numpy as np
+
+# Custom modules (assuming these exist in your project structure)
+from groq import Groq
+# from config import direcindirecprompt
+from utils import groq_calls, write_to_file, get_file_data, get_mongo_collection
+import uvicorn
+
+# Initialize FastAPI app
+app = FastAPI(title="Vidur Yoga Recommendation API")
+
+# Initialize DB connection globally (or within dependency)
+try:
+    collection = get_mongo_collection()
+except Exception as e:
+    print(f"Warning: Database connection failed on startup: {e}")
+    collection = None
+
+# --- Pydantic Models for Request/Response ---
+class AnalysisRequest(BaseModel):
+    username: str = "sameer"  # Default as per your code
+    user_journal: str
+    # Add other fields here if you need to pass user_journal dynamically later
+
+class AnalysisResponse(BaseModel):
+    status: str
+    username: str
+    guidelines: Dict[str, Any]
+    recommended_tasks: List[str]
+    timestamp: datetime
+
+@app.post("/analyze-tasks", response_model=AnalysisResponse)
+def generate_analysis(request: AnalysisRequest):
+    """
+    Executes the analysis pipeline: 
+    1. Identifies direct/indirect problems via Groq.
+    2. Generates guidelines via Groq.
+    3. Matches problems to Yoga tasks using TF-IDF/Cosine Similarity.
+    4. Saves to MongoDB.
+    """
+    
+    example = get_file_data("example.json")
+    direcindirecprompt = f'''
+            I'll be giving you a journal entry written by a user. Your task is to extract out problems being faced by the user in the following format:
+            {{
+            "Overall Problem 1": ["Specific reason1 - reason why it was created", "Specific reason2  - reason why it was created"],
+            "Overall Problem 2": ["Specific reason1 - reason why it was created"],
+            }}
+            I'll give you an example how this overall - specific problem pair looks like. Here you'll see that the heading (single word is the overall problem), then we have the reasons why it was created
+            here is the overall - specific problem pair: {example}
+            Obviusly a single overall problem can have multiple specific reasons why it was created. Put it in the exact format as shown above.
+            Also, multiple overall problems can share a common specific reason why it was created. In that case, just repeat the specific reason under all of them.
+            Here is the user text you have to analyse: {request.user_journal}
+            Output strictly in the format given to you no extra symbols or words or anything
+        '''
+
+
+    # 1. Direct/Indirect Problem Identification
+    try:
+        # Assuming direcindirecprompt is imported from config
+        
+        direcindirecgroq_response = groq_calls(direcindirecprompt)
+        # If the response acts as a JSON source, we try to parse it to ensure validity
+        # parsed_check = json.loads(direcindirecgroq_response) 
+    except Exception as e:
+        raise HTTPException(status_code=502, detail=f"Groq API Error (Problem Identification): {str(e)}")
+
+    # 2. Guidelines Generation
+    try:
+        guideprompt = f'''
+        So, I am giving a set of direct-indirect problem pair, here it is: {direcindirecgroq_response}
+        Now, these are some of the issues the user is facing in his daily life. Assume that you're a very skilled psychologist and help solve the problems faced
+        by the users in their daily life by recommending them a set of guidelines of what they could follow or practice in their daily life to keep themselves calm
+        These guidelines should not be very long, some short recommendations which can be followed even when the person is seated on his chair in office
+        or any where else. Basically the guidelines should be accessible/doable any time.
+        Give 1-2 guidelines for each of the problem that the user is facing as in the problem pair procided to you
+
+        Here are some examples of how guidelines could look like
+        -Take short breaks for deep breathing, walk in the present, and journal three things you're grateful for daily to shift perspective.
+        -Dedicate even 10 minutes to a hobby or enjoyable activity to recharge. 
+        -Reduce news consumption and screen time, especially before bed, to avoid overwhelm.
+
+        Above are some examples only, but remember whatever you suggest should be relevant to the problems the user is facing
+        Final output should be in JSON format only
+        final output should start and end like this
+        {{
+            "problem1": ["Set dedicated focus blocks...", "Use a private tracker..."]
+        }} 
+        '''
+        guidegroq_response = groq_calls(guideprompt)
+    except Exception as e:
+        raise HTTPException(status_code=502, detail=f"Groq API Error (Guideline Generation): {str(e)}")
+
+    # 3. Load Task Dataset
+    try:
+        with open("structured_output_updated.json", "r") as f:
+            task_dataset = json.load(f)
+    except FileNotFoundError:
+        raise HTTPException(status_code=500, detail="Server Error: 'structured_output_updated.json' file not found.")
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=500, detail="Server Error: Failed to decode task dataset JSON.")
+
+    # 4. Process Yoga Branches (Business Logic)
+    try:
+        result = {}
+        yogabranches = list(task_dataset["Yoga"]["branches"].keys())
+        
+        for branch in yogabranches: 
+            if branch == "Asana":
+                postures = list(task_dataset["Yoga"]["branches"][branch].keys())
+                result[f"{branch}s"] = {}
+                for posture in postures:
+                    # Depending on structure, sometimes keys are poses
+                    lst = list(task_dataset["Yoga"]["branches"][branch][posture].keys())
+                    for pose in lst:
+                        sliced_items = list(task_dataset["Yoga"]["branches"][branch][posture][pose].values())[:2]
+                        result[f"{branch}s"][pose] = list(itertools.chain.from_iterable(sliced_items))
+            else:
+                postures = list(task_dataset["Yoga"]["branches"][branch].keys())
+                result[f"{branch}s"] = {}
+                for posture in postures:
+                    lst = list(task_dataset["Yoga"]["branches"][branch][posture].values())[:2]
+                    result[f"{branch}s"][posture] = list(itertools.chain.from_iterable(lst))
+    except KeyError as e:
+        raise HTTPException(status_code=500, detail=f"Data Processing Error: Key {str(e)} missing in dataset.")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Data Processing Error: {str(e)}")
+
+    # 5. Cosine Similarity Preparation
+    try:
+        # We parse the response from Step 1 to get keys for the next prompt
+        user_problem_raw = json.loads(direcindirecgroq_response)
+        
+        cosineprompt = f'''
+        So i am giving you the iverall problems that are being faced by the user. Here it is: {user_problem_raw.keys()}
+        Now I want you to generate a 2-3 line summary/description for each of the problems. It shuold indicate what effect it has on the user's body and mind.
+        So basically I want to perform a cosine similarity between this description that you give and a task dataset that has multiple tasks and they have their own descriptions of what they are able to cure
+        So, If you write a good description for each overall problem, then I can match it with the task dataset descriptions to find the best matching tasks for the user.
+        Here are examples of what is present in the task dataset descriptions:
+        "Nadi Shodhana (Alternate Nostril Breathing)": {{
+                  "Stress": [
+                    "Balances left/right brain hemispheres for nervous system equilibrium",
+                    "Reduces cortisol by 27% through symmetrical breathing patterns",
+                    "Creates instant mental clarity during decision fatigue"
+                  ],
+                  "Emotions": [
+                    "Harmonizes emotional extremes by balancing solar/moon energies",
+                    "Resets emotional reactivity through prefrontal cortex activation",
+                    "Integrates logical and intuitive aspects of awareness"
+                  ],
+                  }}
+        "Bakasana (Crow Pose)": {{
+                    "Focus": [
+                      "Develops laser-like concentration to prevent falling",
+                      "Trains mind-body coordination in challenging position",
+                      "Builds mental discipline through fear management"
+                    ],
+                    "Strength": [
+                      "Develops core and wrist strength simultaneously",
+                      "Tones abdominal muscles through active engagement",
+                      "Builds functional arm strength for daily activities"
+                    ],
+                    }}
+        So, you see there is a certain way the descriptions are written for the task and hence you need to generate the descriptions for the overall problems in a similar way so that cosine similarity precisely extracts onyl those tasks which are highly relevant to the overall problems being faced by the user.
+        Also, follow the following format strictly:
+        {{
+        "Overall Problem 1": ["Description"]
+        "Overall Problem 2": ["Description"]
+        }}
+
+        Remember to output not anything else what is said, also don't use very complicated words. You can use some technical words but keep it simple and precise otherwise if those words are present in the task dataset then cosine similaity will be very less.
+        also, replace "Overall Problem 1" with the problem name for which description is being written
+        '''
+        
+        cosinegroq_response = groq_calls(cosineprompt)
+        parsed_cosine_json = json.loads(cosinegroq_response)
+        
+        user_problem = parsed_cosine_json
+        user_problem_text = " ".join(sum(user_problem.values(), []))
+        
+    except json.JSONDecodeError:
+         raise HTTPException(status_code=500, detail="Failed to parse JSON from Groq response (Cosine Prompt).")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error preparing Cosine Similarity data: {str(e)}")
+
+    # 6. Calculate Cosine Similarity
+    try:
+        tasks = {}
+        for branch in result.keys():
+            for pose in result[branch].keys():
+                documents = []
+                desc = ", ".join(result[branch][pose])
+                documents.append(desc)
+                documents.append(user_problem_text)
+                
+                vectorizer = TfidfVectorizer(stop_words='english')
+                tfidf_matrix = vectorizer.fit_transform(documents)
+                
+                # Compare the last doc (user problem) with the first doc (task desc)
+                similarities = cosine_similarity(tfidf_matrix[-1], tfidf_matrix[:-1]).flatten()
+                tasks[f"{branch}({pose})"] = similarities[0] # Take the float value
+        
+        # Sort and take top 5
+        sorted_tasks = dict(sorted(tasks.items(), key=lambda item: item[1], reverse=True))
+        top_tasks = list(sorted_tasks.keys())[:5]
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Math/Vectorization Error: {str(e)}")
+
+    # 7. Database Insertion
+    chat_document = None
+    try:
+        # Try to parse guidelines string to JSON object for cleaner DB storage/Response
+        try:
+            guidelines_obj = json.loads(guidegroq_response)
+        except:
+            guidelines_obj = {"raw_text": guidegroq_response}
+
+        chat_document = {
+            "user_id": request.username,
+            "timestamp": datetime.now(),
+            "problemdesc": direcindirecgroq_response, # Storing raw response string as per original code
+            "guidelines": guidegroq_response,       # Storing raw response string as per original code
+            "tasks": top_tasks
+        }
+
+        if collection is not None:
+            collection.insert_one(chat_document)
+            print("Saved to DB")
+        else:
+            print("Skipped DB save (Collection not available)")
+            
+    except Exception as e:
+        # We log the DB error but might not want to fail the whole request if the calculation succeeded
+        print(f"Failed to save to DB: {e}")
+        # Note: Depending on requirements, you might want to raise HTTPException here or just proceed.
+
+    # 8. Return Response
+    return AnalysisResponse(
+        status="success",
+        username=request.username,
+        guidelines=guidelines_obj,
+        recommended_tasks=top_tasks,
+        timestamp=chat_document["timestamp"] if chat_document else datetime.now()
+    )
+
+if __name__ == "__main__":
+    # Run the app with uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

utils.py

@@ -0,0 +1,68 @@
+import os
+import json
+import itertools
+from groq import Groq
+from dotenv import load_dotenv
+from pymongo import MongoClient
+import certifi
+load_dotenv()
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+
+
+def get_mongo_collection():
+    CONNECTION_STRING = os.getenv("CONNECTION_STRING")
+    DB_NAME = os.getenv("DB_NAME")
+    COLLECTION_NAME = os.getenv("COLLECTION_NAME")
+    try:
+        # Connect with certifi to avoid SSL errors
+        client = MongoClient(CONNECTION_STRING, tlsCAFile=certifi.where())
+        db = client[DB_NAME]
+        return db[COLLECTION_NAME]
+    except Exception as e:
+        print(f"Error connecting to Mongo: {e}")
+        return None
+    
+
+
+
+def get_file_data(filepath):
+    if(filepath.endswith(".json")):
+        with open(filepath,"r") as f:
+            data = json.load(f)
+        return data             
+    else:
+        with open(filepath,"r") as f:
+            data = f.read()
+        return data
+
+
+def groq_calls(prompt):
+    client = Groq(api_key=GROQ_API_KEY)
+
+    groq_card = client.chat.completions.create(
+        # 401629
+        messages=[
+            {
+                "role": "user",
+                "content": f"{prompt}",
+            },
+            {
+                "role":"system",
+                "content":"You are a psychologist. Output JSON"
+            }
+        ],
+        model="openai/gpt-oss-20b",
+        response_format={"type": "json_object"}
+    )
+
+    # print(groq_card.choices[0].message.content)
+    return groq_card.choices[0].message.content
+
+
+def write_to_file(output_filename,groq_response):
+    # output_filename = "overall_specific_problempair.json"
+    parsed_json = json.loads(groq_response)
+    with open(output_filename, 'a', encoding='utf-8') as f:
+        json.dump(parsed_json, f)
+
+