Changed the entire project structure

{my_agent → brainstroming_agent}/agent.py

@@ -6,7 +6,7 @@ from langgraph.checkpoint.memory import MemorySaver
 memory = MemorySaver()
 
 
-def build_graph():
+def brainstroming_graph():
     builder = StateGraph(State)
     builder.add_node(caption_image)
     builder.add_node(retrieve)

{my_agent → brainstroming_agent}/utils/nodes.py

@@ -3,15 +3,15 @@ import ast
 from .state import State
 from .tools import retrieve_tool
 from langchain_core.messages import SystemMessage
-from .models_loader import llm , ST
-from .data_loader import load_influencer_data
+from utils.models_loader import llm , ST
+from utils.data_loader import load_influencer_data
 from groq import Groq
 import os
 from .prompts import image_captioning_prompt , initial_story_prompt , refined_story_prompt , brainstroming_prompt , final_story_prompt
 from langgraph.prebuilt import create_react_agent
 from pydantic import BaseModel , Field
 from langchain_core.tools import tool
-from .validators import BrainstromTopicFormatter
+from .state import BrainstromTopicFormatter
 
 
 
@@ -113,15 +113,8 @@ def generate_brainstroming(state:State)-> State:
   template= brainstroming_prompt(state)
 
   messages = [SystemMessage(content=template)]
-  response = llm.bind_tools([BrainstromTopicFormatter]).invoke(messages)
-  print('The response is:',response)
-  if hasattr(response, 'tool_calls') and response.tool_calls:
-      response = response.tool_calls[0]['args']
-  elif hasattr(response, 'content'):
-      response = response.content
-  else:
-    response = "No response"
-
+  response = llm.with_structured_output(BrainstromTopicFormatter).invoke(messages)
+  response = response.model_dump()
   state.brainstroming_topics.append(response)
   print('The brainstroming topics are:',state.brainstroming_topics)
   # return State(messages="Story generated",topic=state.topic,brainstroming_topics=state.brainstroming_topics)

{my_agent → brainstroming_agent}/utils/state.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict , Field
 from typing import Optional
 import pandas as pd
 
@@ -15,4 +15,11 @@ class State(BaseModel):
     latest_preferred_topics: Optional[list] = []
     images: Optional[list[str]] = []  # Base64-encoded strings of images
     image_captions: Optional[list] = []
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class BrainstromTopicFormatter(BaseModel):
+    topic1:str=Field(description="First brainstorming topic of the story")
+    topic2:str=Field(description="Second brainstorming topic of the story")
+    topic3:str=Field(description="Third brainstorming topic of the story")
+    topic4:str=Field(description="Fourth brainstorming topic of the story")

{my_agent → brainstroming_agent}/utils/tools.py

@@ -5,8 +5,8 @@ load_dotenv()
 import os
 import numpy as np
 from langchain_core.tools import tool
-from .data_loader import load_influencer_data
-from .models_loader import  ST , llm
+from utils.data_loader import load_influencer_data
+from utils.models_loader import  ST , llm
 from sklearn.metrics.pairwise import cosine_similarity
 import numpy as np
 from langchain_core.messages import SystemMessage

{my_agent → brainstroming_agent}/utils/utils.py

@@ -1,7 +1,6 @@
 
 from langchain_core.messages import SystemMessage
-from .tools import StoryFormatter , retrieve_tool
-from .models_loader import llm
+from .tools import retrieve_tool
 import base64
 from PIL import Image
 from io import BytesIO
@@ -16,7 +15,7 @@ import ast
 import faiss
 import re
 import numpy as np
-from .models_loader import ST
+from utils.models_loader import ST , llm
 
 
 

my_agent/utils/business_interaction.py → business_interaction_agent/agent.py

@@ -1,26 +1,44 @@
-import os
 from langchain_groq import ChatGroq
 from langgraph.graph import StateGraph, MessagesState, START, END
 from langgraph.checkpoint.memory import MemorySaver
-from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
-from pydantic import BaseModel, ConfigDict, Field
-from typing import Optional, List
-from .models_loader import llm,ST
-from .prompts import introduction_prompt , business_interaction_prompt, business_retrieval_prompt
-from .tools import retrieve_tool
 from langgraph.prebuilt import create_react_agent
-from .utils import manual_retrieval
-
+from .utils.state import State
+# from .utils.nodes import business_interaction_node, cleanup_messages
+from utils.models_loader import llm
+from langchain_core.messages import SystemMessage
+from .utils.prompts import business_retrieval_prompt
+from .utils.utils import manual_retrieval
 
+business_state = State()
 
+# class BusinessInteractionChatbot:
+#     def __init__(self):
+#         self.messages = []
+#         self.business_details = None
+#         self.react_agent = create_react_agent(model=llm, tools=[])
+#         self.memory = MemorySaver()
+#         self.workflow = self._initialize_workflow()
+#         self.interact_agent = self.workflow.compile(checkpointer=self.memory)
 
-# State model
-class State(BaseModel):
-    interactions: Optional[list] = []
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+#     def _initialize_workflow(self):
+#         workflow = StateGraph(MessagesState)
+#         workflow.add_node("chatbot", lambda state: business_interaction_node(
+#             state, llm, self.react_agent, self.messages, self.business_details))
+#         workflow.add_node("remove_message", lambda state: cleanup_messages(self.messages))
+#         workflow.add_edge(START, "chatbot")
+#         workflow.add_edge("chatbot", "remove_message")
+#         workflow.add_edge("chatbot", END)
+#         return workflow
 
-# Global business state (shared)
-business_state = State()
+#     def chat(self, user_input: str, business_details: dict):
+#         self.business_details = business_details
+#         self.messages.append({"role": "user", "content": user_input})
+#         config = {"configurable": {"thread_id": "2"}}
+#         response = self.interact_agent.invoke({"messages": self.messages}, config)['messages'][-1].content
+#         self.messages.append({"role": "assistant", "content": response})
+#         business_state.interactions.append({'user': user_input, 'agent_response': response})
+#         return response
+    
 
 class BusinessInteractionChatbot:
     def __init__(self):
@@ -51,7 +69,7 @@ class BusinessInteractionChatbot:
     def _call_model(self, state):
         print('Entered into callmodel')
         retrievals = manual_retrieval(str([msg['content'] for msg in self.messages if msg['role'] == 'user']),self.business_details)
-        template = business_retrieval_prompt(str([msg['content'] for msg in self.messages if msg['role'] == 'user']),retrievals)
+        template = business_retrieval_prompt(str([msg['content'] for msg in self.messages if msg['role'] == 'user']),retrievals,str(self.business_details))
         messages = [SystemMessage(content=template)] + state["messages"]
         backup_response = self.react_agent.invoke({'messages':messages})['messages'][-1]
         print('Backup response:',backup_response.content)
@@ -68,4 +86,4 @@ class BusinessInteractionChatbot:
         self.messages.append({"role": "assistant", "content": response})
         print('The message_history:',self.messages)
         business_state.interactions.append({'user': user_input, 'agent_response': response})
-        return response
+        return response

business_interaction_agent/utils/nodes.py

@@ -0,0 +1,20 @@
+from langchain_core.messages import SystemMessage
+from .prompts import business_retrieval_prompt
+from .utils import manual_retrieval
+
+# This node generates a response using business context and retrieval
+def business_interaction_node(state, llm, react_agent, messages, business_details):
+    print('Entered into callmodel')
+    user_inputs = str([msg['content'] for msg in messages if msg['role'] == 'user'])
+    retrievals = manual_retrieval(user_inputs, business_details)
+    template = business_retrieval_prompt(user_inputs, retrievals)
+    formatted_messages = [SystemMessage(content=template)] + state["messages"]
+    response = react_agent.invoke({'messages': formatted_messages})['messages'][-1]
+    print('Backup response:', response.content)
+    return {"messages": [response.content]}
+
+# Optional message cleanup node
+def cleanup_messages(messages):
+    if len(messages) > 4:
+        return messages[2:]
+    return messages

business_interaction_agent/utils/prompts.py

@@ -0,0 +1,44 @@
+def business_retrieval_prompt(user_message, retrievals, business_details):
+    return f'''
+You are a professional AI assistant helping users understand how influencers can support their business. You will be given:
+
+- A **user message**
+- A list of **retrieved influencer data**
+- The **business details** provided by the user
+
+Your job is to:
+1. **First**, analyze the user message and decide if it is actually a business-related question or query that could be answered using influencer content.
+    - If the message is just a casual greeting like “Hi”, “Hello”, “How are you?”, or is not business-related (e.g., “Who are you?”, “Tell me a joke”), then **do NOT use the retrievals or business details**. Just respond to the user naturally and politely.
+
+2. **If the message is business-related**, proceed to:
+    a. Analyze the **business details** and check if the user message aligns with the type of business.
+        - If there is a mismatch (e.g., business is a restaurant but the user asks about clothing), politely **alert the user** about the mismatch.
+        - Still, go ahead and provide a helpful answer using relevant influencer data if available.
+    b. Analyze the influencer data and explain how each influencer might support the business based only on the retrieved content.
+
+--- USER MESSAGE ---
+{user_message}
+
+--- BUSINESS DETAILS ---
+{business_details}
+
+--- START OF RETRIEVALS ---
+{retrievals}
+--- END OF RETRIEVALS ---
+
+Rules:
+- If the user message is **not relevant to influencer or business help**, politely respond in a general helpful way and ignore the retrievals and business details.
+- If the message **is relevant**, then:
+  - First verify if the user’s business type matches the context of their message.
+  - If not, display a short alert to the user like: “Note: Your query seems to focus on [X], but your business is about [Y].”
+  - Then analyze the influencer stories:
+    - Identify which influencer content is relevant.
+    - Explain what they are promoting and how it might help the business.
+    - You **must mention influencer usernames** and only use what is in the retrievals.
+- Do NOT invent or assume any information beyond what is explicitly provided in the retrievals and business details.
+
+Keep your response:
+- Context-aware
+- Grounded only in the given data
+- Helpful, concise, and user-friendly
+'''

business_interaction_agent/utils/state.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel, ConfigDict
+from typing import Optional
+
+class State(BaseModel):
+    interactions: Optional[list] = []
+    model_config = ConfigDict(arbitrary_types_allowed=True)

business_interaction_agent/utils/utils.py

@@ -0,0 +1,67 @@
+import pandas as pd
+import faiss
+import re
+from utils.models_loader import ST
+import numpy as np
+import ast
+
+
+
+def manual_retrieval(messages, business_details):
+    # === Load CSV ===
+    csv_path = 'extracted_data.csv'
+    df = pd.read_csv(csv_path)
+
+    # === Parse stored embeddings ===
+    df['embeddings'] = df['embeddings'].apply(lambda x: ast.literal_eval(x) if isinstance(x, str) else x)
+    embeddings = np.vstack(df['embeddings'].values).astype('float32')
+
+    # === Build FAISS index ===
+    dimension = embeddings.shape[1]
+    index = faiss.IndexFlatL2(dimension)
+    index.add(embeddings)
+
+    # === Load SentenceTransformer model ===
+
+    # === Encode the query and search ===
+    query_embedding = ST.encode(str(messages)+str(business_details)).reshape(1, -1).astype('float32')
+    top_k=3
+    distances, indices = index.search(query_embedding, top_k)
+
+    # === Function to extract sections 1 and 6 ===
+    def extract_story_and_branding(full_story):
+        full_story = full_story.replace('**6. Visible Texts or Brandings**', '**6. Visible Texts or Brandings:**')
+        full_story = full_story.replace('**1. Story**', '**1. Story:**')
+
+        pattern = (
+            r"\*\*1\. Story:\*\*(.*?)(?=\*\*\d+\.\s)"
+            r".*?"
+            r"\*\*6\. Visible Texts or Brandings:\*\*(.*?)(?=\*\*\d+\.\s|$)"
+        )
+        match = re.search(pattern, full_story, re.DOTALL)
+        if match:
+            story_section = match.group(1).strip()
+            branding_section = match.group(2).strip()
+            return f"Story:\n{story_section}\n\nVisible Texts or Brandings:\n{branding_section}"
+        else:
+            return "Requested sections not found."
+
+    # === Format results ===
+    outer_list = []
+    for i, idx in enumerate(indices[0]):
+        res = {
+            'rank': i + 1,
+            'username': df.iloc[idx]['username'],
+            'agentic_story': df.iloc[idx]['agentic_story'],
+            'likesCount': df.iloc[idx]['likesCount'],
+            'commentCount': df.iloc[idx]['commentCount'],
+            'distance': distances[0][i]
+        }
+
+        inner_list = []
+        inner_list.append(f"[{res['rank']}]. The influencer name is: **{res['username']}** — Likes: **{res['likesCount']}**, Comments: **{res['commentCount']}**")
+        inner_list.append(f"The story of that particular video is:\n{extract_story_and_branding(res['agentic_story'])}")
+        inner_list.append(f"Distance: {res['distance']:.4f}")
+        outer_list.append(inner_list)
+
+    return str(outer_list)

my_agent/utils/initial_interaction.py → context_analysis_agent/agent.py

@@ -1,27 +1,15 @@
-import os
 from langchain_groq import ChatGroq
 from langgraph.graph import StateGraph, MessagesState, START, END
 from langgraph.checkpoint.memory import MemorySaver
-from langchain_core.messages import SystemMessage
-from pydantic import BaseModel, ConfigDict, Field
-from typing import Optional, List
-from .models_loader import llm
-from .prompts import introduction_prompt , details_extract_prompt
-from .validators import DetailsFormatter
+from .utils.state import State
+from .utils.nodes import introduction_node, extract_business_details
+from utils.models_loader import llm
 
-
-# State model
-class State(BaseModel):
-    interactions: Optional[list] = []
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-# Global business state (shared)
 business_state = State()
 
 class IntroductionChatbot:
     def __init__(self):
         self.memory = MemorySaver()
-        # self.llm = ChatGroq(model_name="Gemma2-9b-It")
         self.llm = llm
         self.workflow = self._initialize_workflow()
         self.interact_agent = self.workflow.compile(checkpointer=self.memory)
@@ -29,17 +17,11 @@ class IntroductionChatbot:
 
     def _initialize_workflow(self):
         workflow = StateGraph(MessagesState)
-        workflow.add_node("chatbot", self._call_model)
+        workflow.add_node("chatbot", lambda state: introduction_node(state, self.llm))
         workflow.add_edge(START, "chatbot")
         workflow.add_edge("chatbot", END)
         return workflow
 
-    def _call_model(self, state):
-        template = introduction_prompt
-        messages = [SystemMessage(content=template)] + state["messages"]
-        response = self.llm.invoke(messages)
-        return {"messages": [response]}
-
     def chat(self, user_input: str):
         self.messages.append({"role": "user", "content": user_input})
         config = {"configurable": {"thread_id": "1"}}
@@ -52,10 +34,6 @@ class IntroductionChatbot:
         return "Thanks for providing all your required business details" in latest_response
 
     def extract_details(self):
-        template = details_extract_prompt(business_state.interactions)
-
-        messages = [SystemMessage(content=template)]
-        response = self.llm.with_structured_output(DetailsFormatter).invoke(messages)
-        print('Extracetd details:',response)
-        return response
-
+        response = extract_business_details(business_state.interactions)
+        print('Extracted details:', response)
+        return response