Code refactoring

api/routers/ideation.py

@@ -2,11 +2,12 @@ import ast
 from fastapi import APIRouter
 from fastapi.responses import StreamingResponse
 from api.stored_data import stored_data
-from src.genai.ideation_agent.agent import ideation_graph
+from src.genai.ideation_agent.agent import IdeationAgent
 from langgraph.errors import GraphRecursionError
 
 router = APIRouter()
-idea_graph = ideation_graph()
+agent = IdeationAgent()
+idea_graph = agent.ideation_graph()
 
 @router.post("/ideation")
 def ideation_endpoint():

api/routers/orchestration.py

@@ -4,7 +4,7 @@ from fastapi import APIRouter, Depends
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 from api.stored_data import stored_data
-from src.genai.orchestration_agent.agent import orchestration_chat
+from src.genai.orchestration_agent.agent import OrchestrationAgent
 from typing import Optional
 
 class OrchestrationRequest(BaseModel):
@@ -12,11 +12,11 @@ class OrchestrationRequest(BaseModel):
     image_base64 : Optional[list] = []
 
 router= APIRouter()
-
+agent = OrchestrationAgent()
 @router.post("/orchestration")
 def orchestration_endpoint(request:OrchestrationRequest):
     print('Image:',request.image_base64)
-    result = orchestration_chat(request.message , request.image_base64)
+    result = agent.chat(request.message , request.image_base64)
     if result.image_caption != '': stored_data['image_caption']=result.image_caption
     if result.video_idea !='' or result.video_idea != 'null': stored_data['refined_ideation']= result.video_idea
     if result.video_story!='' or result.video_story!='null': stored_data['final_story']= result.video_story

api/routers/show_analytics.py

@@ -1,9 +1,9 @@
 from fastapi import APIRouter
 from api.stored_data import stored_data
-from src.genai.orchestration_agent.utils.utils import show_analytics
+from src.genai.orchestration_agent.utils.utils import AnalyticsViewer
 
 router=APIRouter()
 @router.post("/show-analytics")
 def show_analytics_endpoint():
-    response = show_analytics(stored_data['business_details'])
+    response = AnalyticsViewer(stored_data['business_details']).show_analytics()
     return {'response': response}

logs/access.log

@@ -206,3 +206,38 @@
 2025-08-11 14:37:03,225 | INFO | access_logger | Request: POST http://127.0.0.1:8000/api/ideation
 2025-08-11 14:39:51,118 | INFO | access_logger | Request: POST http://127.0.0.1:8000/api/ideation
 2025-08-11 14:40:35,783 | INFO | access_logger | Response status: 200
+2025-08-12 17:03:01,254 | INFO | access_logger | Request: GET http://127.0.0.1:8000/docs
+2025-08-12 17:03:01,592 | INFO | access_logger | Response status: 200
+2025-08-12 17:03:01,863 | INFO | access_logger | Request: GET http://127.0.0.1:8000/openapi.json
+2025-08-12 17:03:02,637 | INFO | access_logger | Response status: 200
+2025-08-12 17:03:14,189 | INFO | access_logger | Request: POST http://127.0.0.1:8000/api/show-analytics
+2025-08-12 17:03:25,264 | INFO | access_logger | Response status: 200
+2025-08-13 11:48:42,006 | INFO | access_logger | Request: GET http://127.0.0.1:8000/docs
+2025-08-13 11:48:43,706 | INFO | access_logger | Response status: 200
+2025-08-13 11:48:43,850 | INFO | access_logger | Request: GET http://127.0.0.1:8000/openapi.json
+2025-08-13 11:48:43,866 | INFO | access_logger | Response status: 200
+2025-08-13 11:48:54,938 | INFO | access_logger | Request: POST http://127.0.0.1:8000/api/show-analytics
+2025-08-13 11:48:54,942 | INFO | access_logger | Response status: 200
+2025-08-13 12:14:41,238 | INFO | access_logger | Request: GET http://127.0.0.1:8000/docs
+2025-08-13 12:14:41,260 | INFO | access_logger | Response status: 200
+2025-08-13 12:14:41,406 | INFO | access_logger | Request: GET http://127.0.0.1:8000/openapi.json
+2025-08-13 12:14:41,418 | INFO | access_logger | Response status: 200
+2025-08-13 12:14:46,506 | INFO | access_logger | Request: POST http://127.0.0.1:8000/api/show-analytics
+2025-08-13 12:14:46,510 | INFO | access_logger | Response status: 200
+2025-08-13 13:53:14,104 | INFO | access_logger | Request: GET http://127.0.0.1:8000/openapi.json
+2025-08-13 13:53:14,154 | INFO | access_logger | Response status: 200
+2025-08-13 13:53:22,748 | INFO | access_logger | Request: POST http://127.0.0.1:8000/api/show-analytics
+2025-08-13 13:53:24,417 | INFO | access_logger | Response status: 200
+2025-08-13 13:53:36,718 | INFO | access_logger | Request: POST http://127.0.0.1:8000/api/orchestration
+2025-08-13 13:53:44,587 | INFO | access_logger | Response status: 200
+2025-08-13 13:54:08,702 | INFO | access_logger | Request: POST http://127.0.0.1:8000/api/orchestration
+2025-08-13 13:54:18,367 | INFO | access_logger | Response status: 200
+2025-08-13 13:55:29,606 | INFO | access_logger | Request: POST http://127.0.0.1:8000/api/orchestration
+2025-08-13 13:55:45,000 | INFO | access_logger | Response status: 200
+2025-08-13 17:20:37,737 | INFO | access_logger | Request: POST http://127.0.0.1:8000/api/ideation
+2025-08-13 17:22:51,262 | INFO | access_logger | Request: POST http://127.0.0.1:8000/api/ideation
+2025-08-13 17:23:31,261 | INFO | access_logger | Response status: 200
+2025-08-13 17:24:19,755 | INFO | access_logger | Request: POST http://127.0.0.1:8000/api/show-analytics
+2025-08-13 17:24:22,399 | INFO | access_logger | Response status: 200
+2025-08-13 17:24:37,955 | INFO | access_logger | Request: POST http://127.0.0.1:8000/api/orchestration
+2025-08-13 17:24:51,218 | INFO | access_logger | Response status: 200

logs/app.log

@@ -1 +1,5 @@
 2025-07-30 16:53:23,605 | INFO | app_logger | Showing Analytics of the influencers after context analysis.
+2025-08-12 17:03:25,262 | INFO | app_logger | Showing Analytics of the influencers after context analysis.
+2025-08-13 11:48:54,941 | ERROR | app_logger | Error while showing analytics: retrieve_data_for_analytics() missing 1 required positional argument: 'business_details'
+2025-08-13 13:53:24,416 | INFO | app_logger | Showing Analytics of the influencers after context analysis.
+2025-08-13 17:24:22,398 | INFO | app_logger | Showing Analytics of the influencers after context analysis.

logs/errors.log

@@ -0,0 +1 @@
+2025-08-13 12:14:46,509 | ERROR | error_logger | Error while showing analytics: retrieve_data_for_analytics() missing 1 required positional argument: 'business_details'

src/genai/ideation_agent/agent.py

@@ -1,32 +1,33 @@
 from langgraph.graph import StateGraph, START, END , MessagesState
 from .utils.state import State
-from .utils.nodes import ideator , critic , format_response , validator1 , validator2 , route1_after_validation , route2_after_validation 
+from .utils.nodes import IdeatorNode , CriticNode , FormatResponseNode, Validators , RoutingsAfterValidation
 from langgraph.checkpoint.memory import MemorySaver
-memory = MemorySaver()
 
+class IdeationAgent:
+    def __init__(self):
+        self.memory = MemorySaver()
 
-def ideation_graph():
-    graph_builder= StateGraph(State)
-    graph_builder.add_node(ideator)
-    graph_builder.add_node(critic)
-    graph_builder.add_node(format_response)
-    graph_builder.add_node(validator1)
-    graph_builder.add_node(validator2)
+    def ideation_graph(self):
+        graph_builder= StateGraph(State)
+        graph_builder.add_node("ideator", IdeatorNode().run)
+        graph_builder.add_node("critic", CriticNode().run)
+        graph_builder.add_node("format_response", FormatResponseNode().run)
+        graph_builder.add_node("validator1", Validators().run_validator1)
+        graph_builder.add_node("validator2", Validators().run_validator2)
 
+        graph_builder.add_edge(START, "ideator")  # Start the graph with node_1
+        graph_builder.add_edge("ideator", "critic")
+        graph_builder.add_edge("critic", "format_response")
+        graph_builder.add_edge("format_response", "validator1")
+        graph_builder.add_edge("validator1", "validator2")
+        graph_builder.add_edge("validator2", END)
 
-    graph_builder.add_edge(START, "ideator")  # Start the graph with node_1
-    graph_builder.add_edge("ideator", "critic")
-    graph_builder.add_edge("critic", "format_response")
-    graph_builder.add_edge("format_response", "validator1")
-    graph_builder.add_edge("validator1", "validator2")
-    graph_builder.add_edge("validator2", END)
 
+        # Use conditional routing from validator
+        graph_builder.add_conditional_edges("validator1", RoutingsAfterValidation().route1,{False:'critic',True:'validator2'})
+        graph_builder.add_conditional_edges("validator2", RoutingsAfterValidation().route2,{False:'critic',True:END})
 
-    # Use conditional routing from validator
-    graph_builder.add_conditional_edges("validator1", route1_after_validation,{False:'critic',True:'validator2'})
-    graph_builder.add_conditional_edges("validator2", route2_after_validation,{False:'critic',True:END})
-
-    return graph_builder.compile(checkpointer=memory)
+        return graph_builder.compile(checkpointer=self.memory)
 
 
 

src/genai/ideation_agent/utils/nodes.py

@@ -1,179 +1,113 @@
 from .state import State , ValidationFormatter , ImproverResponseFormatter, CriticResponseFormatter
-from .tools import retrieve_tool
+from .tools import retrieve_imdb_ideas_tool , retrieve_influencers_data_tool
 from langgraph.prebuilt import create_react_agent
 from src.genai.utils.models_loader import ideator_llm, critic_llm , improver_llm , validator_llm, llm
 from langchain_core.messages import SystemMessage , HumanMessage
 from .prompts import ideator_prompt , critic_prompt , improver_prompt , validator_prompt, idea_refinement_prompt
 
 
+class IdeatorNode:
+    def __init__(self):
+        self.ideator_agent = create_react_agent(model=ideator_llm,  tools=[retrieve_imdb_ideas_tool])
+    
+    def run(self, state:State):
+        template =ideator_prompt(state)
+        messages = [SystemMessage(content=template),
+                    HumanMessage(content=f'''The business_details is\n{state.business_details[-1]}\n 
+                    The information of the image is:\n{state.image_caption[-1]}''')]
+        try:
+            response = self.ideator_agent.invoke({'messages':messages})
+            print('Ideator Response:',response)
+            response = response['messages'][-1].content
+            state.ideator_response.append(response)
+            print('Ideator Generated the story')
+            return state
+        except:
+            response = ideator_llm.invoke(messages)
+            print('Ideator backup Response:',response.content)
+            state.ideator_response.append(response.content)
+            return state
+                
+
+class CriticNode:
+    def __init__(self):
+        self.critic_agent = create_react_agent(model=critic_llm,  tools=[retrieve_imdb_ideas_tool])
+    
+    def run(self,state:State):
+        template = critic_prompt(state)
+        messages = [SystemMessage(content=template),
+                    HumanMessage(content=f'''The business_details is\n{state.business_details[-1]}\n 
+                                The information of the image is:\n{state.image_caption[-1]}''')]
+        
+        try:
+            response = self.critic_agent.invoke({'messages':messages})
+            response = response['messages'][-1].content
+            print('Critic Response:',response)
+            state.critic_response.append(response)
+            print('Critic Evaluated the story')
+            return state
+        
+        except:
+            response = critic_llm.invoke(messages)
+            print('Critic backup Response:',response.content)
+            state.critic_response.append(response.content)
+            return state
+
+class FormatResponseNode:
+    def __init__(self):
+        self.response_list = []
+    
+    def run(self, state:State):
+        messages = [SystemMessage(content='''Just extract all the 4 improved ideas and the faults of critic as it is from the critic's response'''), 
+                    HumanMessage(content=f'''The critic's response is: \n {state.critic_response[-1]}''')]
+        response = critic_llm.with_structured_output(CriticResponseFormatter).invoke(messages)
+        self.response_list.append(response.improved_idea1)
+        self.response_list.append(response.improved_idea2)
+        self.response_list.append(response.improved_idea3)
+        self.response_list.append(response.improved_idea4)
+        state.formatted_response.append(str(self.response_list))
+        state.ideator_fault.append(response.faults)
+        print('Formatted Response:', self.response_list)
+        return state
 
-ideator_agent = create_react_agent(
-    model=ideator_llm,
-    tools=[retrieve_tool]
-    )
-critic_agent = create_react_agent(
-    model=critic_llm,
-    tools=[retrieve_tool]
-    )
-
-improver_agent = create_react_agent(
-    model=improver_llm,
-    tools=[]
-    )
 
 
+class Validators:
+    def __init__(self):
+        self.validator_llm1 = validator_llm
+        self.validator_llm2 = improver_llm
 
-def ideator(state:State):
-    template = ideator_prompt(state)
-    # imdb_reference = retrieve_tool(state.business_details[-1])
-    messages = [SystemMessage(content=template),
-                HumanMessage(content=f'''The business_details is\n{state.business_details[-1]}\n 
-                            The information of the image is:\n{state.image_caption[-1]}''')]
-    try:
-        response = ideator_agent.invoke({'messages':messages})
-        print('Ideator Response:',response)
-        response = response['messages'][-1].content
-        state.ideator_response.append(response)
-        print('Ideator Generated the story')
-        return state
+    def get_response(self,state, validator_llm):
+        template = validator_prompt(state)
+        messages = [SystemMessage(content=template),
+                    HumanMessage(content=f'''The business_details is:\n{state.business_details[-1]}''')]
 
-    except:
-        response = ideator_llm.invoke(messages)
-        print('Ideator backup Response:',response.content)
-        state.ideator_response.append(response.content)
-        return state
-
-def critic(state:State):
-    template = critic_prompt(state)
-    # imdb_reference= retrieve_tool(state.business_details[-1])
-    messages = [SystemMessage(content=template),
-                HumanMessage(content=f'''The business_details is\n{state.business_details[-1]}\n 
-                            The information of the image is:\n{state.image_caption[-1]}''')]
+        response = validator_llm.with_structured_output(ValidationFormatter).invoke(messages)
+        return response
     
-    try:
-        response = critic_agent.invoke({'messages':messages})
-        response = response['messages'][-1].content
-        print('Critic Response:',response)
-        state.critic_response.append(response)
-        print('Critic Evaluated the story')
-        return state
     
-    except:
-        response = critic_llm.invoke(messages)
-        print('Critic backup Response:',response.content)
-        state.critic_response.append(response.content)
+    def run_validator1(self, state:State): 
+        response = self.get_response(state,self.validator_llm1)
+        state.validator1_response.append(response.result)
+        if 'not validated' in response.result: state.disagreement_reason.append(response.reason)
+        return state
+        
+    def run_validator2(self, state:State):
+        response = self.get_response(state,self.validator_llm2)
+        state.validator2_response.append(response.result)
+        if 'not validated' in response.result: state.disagreement_reason.append(response.reason)
         return state
-    
-def format_response(state:State):
-    response_list = []
-    messages = [SystemMessage(content='''Just extract all the 4 improved ideas and the faults of critic as it is from the critic's response'''), 
-                HumanMessage(content=f'''The critic's response is: \n {state.critic_response[-1]}''')]
-    response = critic_llm.with_structured_output(CriticResponseFormatter).invoke(messages)
-    response_list.append(response.improved_idea1)
-    response_list.append(response.improved_idea2)
-    response_list.append(response.improved_idea3)
-    response_list.append(response.improved_idea4)
-    state.formatted_response.append(str(response_list))
-    state.ideator_fault.append(response.faults)
-    print('Formatted Response:', response_list)
-    return state
-
 
 
-# def improver(state:State):
-#     response_list = []
-#     template = improver_prompt(state)
-#     messages = [SystemMessage(content=template),
-#                 HumanMessage(content=f'''The business_details is:\n{state.business_details[-1]}\n The information of the image is:\n{state.image_caption[-1]}''')]
-#     print('Improver Prompt:',messages)
-#     response = improver_llm.with_structured_output(ImproverResponseFormatter).invoke(messages)
-#     response_list.append(response.improved_idea1)
-#     response_list.append(response.improved_idea2)
-#     response_list.append(response.improved_idea3)
-#     response_list.append(response.improved_idea4)
+class RoutingsAfterValidation:
+    def __init__(self):
+        pass
 
-#     state.improver_response.append(str(response_list))
-#     state.critic_fault.append(response.faults)
-#     print('Improver response:',response_list)
-#     return state
+    def route1(self, state:State):
+        return 'not validated' not in state.validator1_response[-1]
     
+    def route2(self, state:State):
+        return 'not validated' not in state.validator2_response[-1]
 
 
-def validator1(state:State):
-    template = validator_prompt(state)
-    messages = [SystemMessage(content=template),
-                HumanMessage(content=f'''The business_details is:\n{state.business_details[-1]}''')]
-
-    response = validator_llm.with_structured_output(ValidationFormatter).invoke(messages)
-    print(f'Validator 1 response: {response}')
-    state.validator1_response.append(response.result)
-    print('The state check:',state.validator1_response[-1])
-    if 'not validated' in response.result:
-        state.disagreement_reason.append(response.reason)
-    return state
-
-def validator2(state:State):
-    template = validator_prompt(state)
-    messages = [SystemMessage(content=template),
-                HumanMessage(content=f'''The business_details is:\n{state.business_details[-1]}''')]
-
-    response = ideator_llm.with_structured_output(ValidationFormatter).invoke(messages)
-    print(f'Validator 2 response: {response}')
-    state.validator2_response.append(response.result)
-    print('The state check:',state.validator2_response[-1])
-    if 'not validated' in response.result:
-        state.disagreement_reason.append(response.reason)
-    return state
-
-# def validator3(state:State):
-#     template = validator_prompt(state)
-#     messages = [SystemMessage(content=template),
-#                 HumanMessage(content=f'''The business_details is:\n{state.business_details[-1]}''')]
-
-#     response = critic_llm.with_structured_output(ValidationFormatter).invoke(messages)
-#     print(f'Validator 3 response: {response}')
-#     state.validator3_response.append(response.result)
-#     print('The state check:',state.validator1_response[-1])
-#     if 'not validated' in response.result:
-#         state.disagreement_reason.append(response.reason)
-#     return state
-
-# def validator4(state:State):
-#     template = validator_prompt(state)
-#     messages = [SystemMessage(content=template),
-#                 HumanMessage(content=f'''The business_details is:\n{state.business_details[-1]}''')]
-
-#     response = improver_llm.with_structured_output(ValidationFormatter).invoke(messages)
-#     print(f'Validator 4 response: {response}')
-#     state.validator4_response.append(response.result)
-#     print('The state check:',state.validator1_response[-1])
-#     if 'not validated' in response.result:
-#         state.disagreement_reason.append(response.reason)
-#     return state
-
-def route1_after_validation(state:State):
-    if 'not validated' in state.validator1_response[-1]:
-        return False
-    else:
-        return True
-
-
-def route2_after_validation(state:State):
-    if 'not validated' in state.validator2_response[-1]:
-        return False
-    else:
-        return True
-
-
-# def route3_after_validation(state:State):
-#     if 'not validated' in state.validator3_response[-1]:
-#         return False
-#     else:
-#         return True
-
 
-# def route4_after_validation(state:State):
-#     if 'not validated' in state.validator4_response[-1]:
-#         return False
-#     else:
-#         return True

src/genai/ideation_agent/utils/tools.py

@@ -10,84 +10,87 @@ from src.genai.utils.models_loader import embedding_model
 from src.genai.utils.load_embeddings import  caption_index , caption_df, ideas_index , ideas_df
 from src.genai.utils.utils import clean_text
 
+
+class Retrieval:
+    def __init__(self, business_details):
+        self.business_details = business_details
+        self.query_embedding =  np.array(embedding_model.embed_query(str(business_details))).reshape(1, -1).astype('float32')
+        faiss.normalize_L2(self.query_embedding)
+
+    def influencers_data(self):
+        top_k = len(caption_df)
+        distances, indices = caption_index.search(self.query_embedding, top_k)
+
+        similarity_threshold = 0.35
+        selected = [(idx, sim) for idx, sim in zip(indices[0], distances[0]) if sim >= similarity_threshold]
+
+        if not selected:
+            return "No influencers found."
+
+        # === Format results ===
+        outer_list = []
+        for rank, (idx, sim) in enumerate(selected, 1):
+            row = caption_df.iloc[idx]
+            res = {
+                'rank': rank,
+                'username': row['username'],
+                'visible_text_or_brandings': row['visible_texts_or_brandings'],
+                'likesCount': row['likesCount'],
+                'commentCount': row['commentCount'],
+                'product_or_service_details': row['product_or_service_details'],
+            }
+
+            inner_list = [
+                f"[{res['rank']}]. The influencer name is: **{res['username']}** — Likes: **{res['likesCount']}**, Comments: **{res['commentCount']}**",
+                f"The branding or promotion done is:\n{res['visible_text_or_brandings']}",
+                f"The details of product or service is:\n{res['product_or_service_details']}"
+            ]
+            outer_list.append(inner_list)
+
+        cleaned_response = clean_text(str(outer_list))
+        encoding = tiktoken.encoding_for_model('gpt-4o-mini')
+        tokens = encoding.encode(cleaned_response)
+        trimmed_response = tokens[:1000]
+        return encoding.decode(trimmed_response)
+    
+    def imdb_ideas(self):
+        top_k = 10
+        distances, indices = ideas_index.search(self.query_embedding, top_k)
+
+        outer_list = []
+        for rank, (idx, sim) in enumerate(zip(indices[0], distances[0]), 1):
+            row = ideas_df.iloc[idx]
+            res = {
+                'rank': rank,
+                'idea': row['idea'],
+            }
+
+            inner_list = [
+                f"Idea [{res['rank']}]: **{res['idea']}\n**",
+            ]
+            outer_list.append(inner_list)
+
+        cleaned_response = clean_text(str(outer_list))
+        return str(cleaned_response)
+
+
+
+
 @tool("influencers_data_retrieval_tool", args_schema=QueryFormatter, return_direct=False,description="Retrieve influencer-related data for a given query.")
-def retrieve_tool_old(business_details):
+def retrieve_influencers_data_tool(business_details):
     '''
     Always invoke this tool.
     Retrieve influencer's data by semantic search of **business details**.
     '''
-    query_embedding = np.array(embedding_model.embed_query(str(business_details))).reshape(1, -1).astype('float32')
-    faiss.normalize_L2(query_embedding)
-
-    top_k = len(caption_df)
-    distances, indices = caption_index.search(query_embedding, top_k)
-
-    similarity_threshold = 0.35
-    selected = [(idx, sim) for idx, sim in zip(indices[0], distances[0]) if sim >= similarity_threshold]
-
-    if not selected:
-        return "No influencers found."
-
-    # === Format results ===
-    outer_list = []
-    for rank, (idx, sim) in enumerate(selected, 1):
-        row = caption_df.iloc[idx]
-        res = {
-            'rank': rank,
-            'username': row['username'],
-            'visible_text_or_brandings': row['visible_texts_or_brandings'],
-            'likesCount': row['likesCount'],
-            'commentCount': row['commentCount'],
-            'product_or_service_details': row['product_or_service_details'],
-        }
-
-        inner_list = [
-            f"[{res['rank']}]. The influencer name is: **{res['username']}** — Likes: **{res['likesCount']}**, Comments: **{res['commentCount']}**",
-            f"The branding or promotion done is:\n{res['visible_text_or_brandings']}",
-            f"The details of product or service is:\n{res['product_or_service_details']}"
-        ]
-        outer_list.append(inner_list)
-
-    cleaned_response = clean_text(str(outer_list))
-    encoding = tiktoken.encoding_for_model('gpt-4o-mini')
-    tokens = encoding.encode(cleaned_response)
-    trimmed_response = tokens[:1000]
-    return encoding.decode(trimmed_response)
-
-
-# @tool("imdb_movies_ideas_retrieval_tool", args_schema=QueryFormatter, return_direct=False,description="Retrieve imdb movies-related idea for a given query.")
-def retrieve_tool(business_details):
+    return Retrieval(business_details).influencers_data()
+
+
+@tool("imdb_movies_ideas_retrieval_tool", args_schema=QueryFormatter, return_direct=False,description="Retrieve imdb movies-related idea for a given query.")
+def retrieve_imdb_ideas_tool(business_details):
     '''
     Always invoke this tool.
     Retrieve the ideas of imdb_movies by semantic search of **business details**.
     '''
-    query_embedding = np.array(embedding_model.embed_query(str(business_details))).reshape(1, -1).astype('float32')
-    faiss.normalize_L2(query_embedding)
-
-    top_k = 10
-    distances, indices = ideas_index.search(query_embedding, top_k)
-
-    outer_list = []
-    for rank, (idx, sim) in enumerate(zip(indices[0], distances[0]), 1):
-        row = ideas_df.iloc[idx]
-        res = {
-            'rank': rank,
-            'idea': row['idea'],
-        }
-
-        inner_list = [
-            f"Idea [{res['rank']}]: **{res['idea']}\n**",
-        ]
-        outer_list.append(inner_list)
-
-    cleaned_response = clean_text(str(outer_list))
-    return str(cleaned_response)
-
-# business_details= {
-#     "business_type": "restaurant",
-#     "platform": "instagram",
-#     "target_audience": "youths",
-#     "business_goals": "to increase sales",
-#     "offerings": "nepali local foods",
-#     "Challenges_faced": "competition with other restaurants"
-#   },
+    return Retrieval(business_details).imdb_ideas()
+
+

src/genai/orchestration_agent/agent.py

@@ -1,56 +1,64 @@
 from langgraph.graph import StateGraph, MessagesState, START, END
 from langgraph.checkpoint.memory import MemorySaver
-from .utils.nodes import tool_return_node, extract_user_reference_node
+from .utils.nodes import ToolReturnNode, ExtractUserReferenceNode
 from src.genai.utils.models_loader import llm_gpt
 from .utils.state import ValidationFormatter
-from .utils.utils import caption_image , extract_latest_response_block
-from .utils.tools import retrieve_data_for_orchestration
+from .utils.utils import ImageCaptioner, ResponseBlockExtractor
+from .utils.tools import InfluencerRetrievalTool
 
 import re
 from langchain_core.messages import SystemMessage
-memory = MemorySaver()
-
-
-def orchestration_graph():
-    workflow = StateGraph(MessagesState)
-    workflow.add_node("chatbot1", tool_return_node)
-    workflow.add_node("chatbot2", extract_user_reference_node)
-
-    workflow.add_edge(START, "chatbot1")
-    workflow.add_edge('chatbot1', "chatbot2")
-    workflow.add_edge('chatbot2', END)
-    return workflow.compile(checkpointer=memory)
-
-user_input_history = []
-def orchestration_chat(user_input: str, image_base64=[]):
-    print('Message Chunk:')
-    global user_input_history
-    user_input_history.append({'role': 'human', 'content': user_input})
-
-    if len(image_base64)>0:
-        caption_response = caption_image(image_base64, user_input)
-        user_input_history.append({'role': 'image_caption', 'content': caption_response})
-
-        print('Caption Response:', caption_response)
-    else:
-        caption_response =''
-    if len(user_input_history)>4:
-        user_input_history=user_input_history[-2:]
-    print('Length of history', len(user_input_history))
-    query_for_retrieval = ' '.join(
-    [msg['content'] for msg in user_input_history if msg['role'] in ('human', 'image_caption')]
-    )
-
-    influencers_data = retrieve_data_for_orchestration(query_for_retrieval)
-
-    agent = orchestration_graph()
-    config = {"configurable": {"thread_id": "orchestration-thread"}}
-    response = agent.invoke({"messages": [{'role':'human','content':user_input},
-                                          {'role': 'function', 'name': 'data_of_influencers', 'content': influencers_data},
-                                          {'role':'function','name':'information_of_image','content':caption_response}]}, config)['messages']
-    print('Orchestrator Response', response)
-    response=llm_gpt.with_structured_output(ValidationFormatter).invoke(extract_latest_response_block(response))
-    return response
+
+class OrchestrationAgent:
+    def __init__(self):
+        self.memory = MemorySaver()
+        self.agent = self.orchestration_graph()
+        self.user_input_history=[]
+
+    def orchestration_graph(self):
+        workflow = StateGraph(MessagesState)
+        workflow.add_node("chatbot1", ToolReturnNode().run)
+        workflow.add_node("chatbot2", ExtractUserReferenceNode().run)
+
+        workflow.add_edge(START, "chatbot1")
+        workflow.add_edge('chatbot1', "chatbot2")
+        workflow.add_edge('chatbot2', END)
+        return workflow.compile(checkpointer=self.memory)
+    
+    def trim_history(self):
+        if len(self.user_input_history)>4:
+            self.user_input_history=self.user_input_history[-2:]
+        print('Length of history', len(self.user_input_history))
+        query_for_retrieval = ' '.join(
+        [msg['content'] for msg in self.user_input_history if msg['role'] in ('human', 'image_caption')])
+        return query_for_retrieval
+    
+    def caption_image(self,image_base64,user_input):
+        if len(image_base64)>0:
+            caption_response = ImageCaptioner().caption_image(image_base64,user_input)
+            self.user_input_history.append({'role': 'image_caption', 'content': caption_response})
+
+            print('Caption Response:', caption_response)
+        else:
+            caption_response =''
+        return caption_response
+
+
+    def chat(self,user_input: str, image_base64=[]):
+        print('Message Chunk:')
+        self.user_input_history.append({'role': 'human', 'content': user_input})
+        caption_response = self.caption_image(image_base64,user_input)
+        query_for_retrieval= self.trim_history()
+
+        influencers_data = InfluencerRetrievalTool().retrieve_for_orchestration(query_for_retrieval)
+
+        config = {"configurable": {"thread_id": "orchestration-thread"}}
+        response = self.agent.invoke({"messages": [{'role':'human','content':user_input},
+                                            {'role': 'function', 'name': 'data_of_influencers', 'content': influencers_data},
+                                            {'role':'function','name':'information_of_image','content':caption_response}]}, config)['messages']
+        print('Orchestrator Response', response)
+        response=llm_gpt.with_structured_output(ValidationFormatter).invoke(ResponseBlockExtractor(response).extract_latest())
+        return response
 
     
 

src/genai/orchestration_agent/utils/nodes.py

@@ -3,24 +3,38 @@ from langchain_core.messages import SystemMessage, HumanMessage
 from src.genai.utils.models_loader import llm_gpt
 from .state import  ToolResponseFormatter, UserReferenceResponseFormatter
 
+class ToolReturnNode:
+    """Node for determining which tools to use based on user messages."""
+
+    def __init__(self, llm=llm_gpt):
+        self.llm = llm
+
+    def run(self, state):
+        if len(state["messages"]) > 23:
+            state["messages"] = state["messages"][-18:]
+        template = [SystemMessage(content=tool_return_prompt)] + state["messages"]
+        response = self.llm.with_structured_output(ToolResponseFormatter).invoke(template)
+        return {"messages": [{'role': 'assistant', 'content': f"The exact name of the tool is: {response}"}]}
+
+
+class ExtractUserReferenceNode:
+    """Node for extracting video idea and story from user's messages."""
+
+    def __init__(self, llm=llm_gpt):
+        self.llm = llm
+
+    def run(self, state):
+        latest_human_message = next(
+            (msg for msg in reversed(state['messages']) if isinstance(msg, HumanMessage)),
+            None
+        )
+        template = [SystemMessage(content=extract_user_reference_prompt),
+                    HumanMessage(content=latest_human_message.content)]
+        response = self.llm.with_structured_output(UserReferenceResponseFormatter).invoke(template)
+        return {'messages': [{
+            'role': 'assistant',
+            'content': f"The video idea is: {response.video_idea} and the video story is: {response.video_story}"
+        }]}
+
 
 
-def tool_return_node(state):
-    if len(state["messages"]) > 23:
-        state["messages"] = state["messages"][-18:]
-    history = state["messages"]
-    template = [SystemMessage(content=tool_return_prompt)] + history
-    # print(template)
-    response = llm_gpt.with_structured_output(ToolResponseFormatter).invoke(template)
-    print(response)
-    return {"messages": [{'role':'assistant','content':f'''The exact name of the tool is: {response}'''}]}
-
-def extract_user_reference_node(state):
-    history = state['messages']
-    latest_human_message = next(
-    (msg for msg in reversed(history) if isinstance(msg, HumanMessage)),
-    None
-    )
-    template = [SystemMessage(content=extract_user_reference_prompt), HumanMessage(content=latest_human_message.content)]
-    response = llm_gpt.with_structured_output(UserReferenceResponseFormatter).invoke(template)
-    return {'messages': [{'role':'assistant','content':f'''The video idea is: {response.video_idea} and the video story is: {response.video_story}'''}]}

src/genai/orchestration_agent/utils/tools.py

@@ -7,71 +7,54 @@ from src.genai.utils.models_loader import embedding_model
 from src.genai.utils.utils import clean_text
 import tiktoken
 
-def retrieve_data_for_analytics(business_details):
-    '''
-    Always invoke this tool.
-    Retrieve influencer's data by semantic search of **business details**.
-    '''
-    # df = pd.read_csv('extracted_data.csv')
 
-    # === Encode the query and search ===
-    query_embedding = np.array(embedding_model.embed_query(str(business_details))).reshape(1, -1).astype('float32')
-    top_k = 10
-    distances, indices = caption_index.search(query_embedding, top_k)
+class InfluencerRetrievalTool:
+    """Tool for retrieving influencer data based on semantic search."""
+
+    def __init__(self):
+        self.df = caption_df
+        self.index = caption_index
+
+    def retrieve_for_analytics(self, business_details):
+        query_embedding = np.array(embedding_model.embed_query(str(business_details))).reshape(1, -1).astype('float32')
+        distances, indices = self.index.search(query_embedding, 10)
+        results = []
+        for idx in indices[0]:
+            row = self.df.iloc[idx]
+            results.append({
+                'url': row['videoUrl'],
+                'username': row['username'],
+                'likesCount': int(row['likesCount']) if pd.notnull(row['likesCount']) else None,
+                'commentCount': int(row['commentCount']) if pd.notnull(row['commentCount']) else None
+            })
+        return results
+
+    def retrieve_for_orchestration(self, query):
+        query_embedding = np.array(embedding_model.embed_query(str(query))).reshape(1, -1).astype('float32')
+        faiss.normalize_L2(query_embedding)
+        distances, indices = self.index.search(query_embedding, len(self.df))
+        similarity_threshold = 0.35
+        selected = [(idx, sim) for idx, sim in zip(indices[0], distances[0]) if sim >= similarity_threshold]
+        if not selected:
+            return "No influencers found."
+
+        outer_list = []
+        for rank, (idx, sim) in enumerate(selected, 1):
+            row = self.df.iloc[idx]
+            inner_list = [
+                f"[{rank}]. The influencer name is: **{row['username']}** — Likes: **{row['likesCount']}**, Comments: **{row['commentCount']}**",
+                f"The branding or promotion done is:\n{row['visible_texts_or_brandings']}",
+                f"The details of product or service is:\n{row['product_or_service_details']}"
+            ]
+            outer_list.append(inner_list)
+
+        cleaned_response = clean_text(str(outer_list))
+        encoding = tiktoken.encoding_for_model('gpt-4o-mini')
+        tokens = encoding.encode(cleaned_response)[:1000]
+        return encoding.decode(tokens)
 
-    # === Format results ===
-    results = []
-    for i, idx in enumerate(indices[0]):
-        likes = caption_df.iloc[idx]['likesCount']
-        comments = caption_df.iloc[idx]['commentCount']
-        res = {
-            'url': caption_df.iloc[idx]['videoUrl'],
-            'username': caption_df.iloc[idx]['username'],
-            'likesCount': int(likes) if pd.notnull(likes) else None,
-        'commentCount': int(comments) if pd.notnull(comments) else None
-        }
-        results.append(res)
 
-    return results 
 
-def retrieve_data_for_orchestration(query):
-    query_embedding = np.array(embedding_model.embed_query(str(query))).reshape(1, -1).astype('float32')
-    faiss.normalize_L2(query_embedding)
-
-    top_k = len(caption_df)
-    distances, indices = caption_index.search(query_embedding, top_k)
-
-    similarity_threshold = 0.35
-    selected = [(idx, sim) for idx, sim in zip(indices[0], distances[0]) if sim >= similarity_threshold]
-
-    if not selected:
-        return "No influencers found."
-
-    # === Format results ===
-    outer_list = []
-    for rank, (idx, sim) in enumerate(selected, 1):
-        row = caption_df.iloc[idx]
-        res = {
-            'rank': rank,
-            'username': row['username'],
-            'visible_text_or_brandings': row['visible_texts_or_brandings'],
-            'likesCount': row['likesCount'],
-            'commentCount': row['commentCount'],
-            'product_or_service_details': row['product_or_service_details'],
-        }
-
-        inner_list = [
-            f"[{res['rank']}]. The influencer name is: **{res['username']}** — Likes: **{res['likesCount']}**, Comments: **{res['commentCount']}**",
-            f"The branding or promotion done is:\n{res['visible_text_or_brandings']}",
-            f"The details of product or service is:\n{res['product_or_service_details']}"
-        ]
-        outer_list.append(inner_list)
-
-    cleaned_response = clean_text(str(outer_list))
-    encoding = tiktoken.encoding_for_model('gpt-4o-mini')
-    tokens = encoding.encode(cleaned_response)
-    trimmed_response = tokens[:1000]
-    return encoding.decode(trimmed_response)
 
 
 

src/genai/orchestration_agent/utils/utils.py

@@ -6,63 +6,77 @@ import os
 from .prompts import captioning_prompt
 from src.genai.utils.models_loader import llm
 from langchain_core.messages import FunctionMessage , AIMessage
-from .tools import  retrieve_data_for_analytics
+from .tools import  InfluencerRetrievalTool
 import re
 import logging
 app_logger = logging.getLogger("app_logger")
+error_logger = logging.getLogger("error_logger")
 
-def caption_image(image_base64,user_input):
-    if len(image_base64)>0:
-        print('Captioning image')
-        client = Groq(api_key=os.environ.get('GROQ_API_KEY'))
+class ImageCaptioner:
+    def __init__(self, api_key=os.environ.get('GROQ_API_KEY')):
+        self.client = Groq(api_key=api_key)
 
-        chat_completion = client.chat.completions.create(
-            messages=[
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": captioning_prompt(user_input)},
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": f"data:image/jpg;base64,{image_base64[-1]}",
+    def caption_image(self,image_base64,user_input):
+        if len(image_base64)>0:
+            print('Captioning image')
+            chat_completion = self.client.chat.completions.create(
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": captioning_prompt(user_input)},
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:image/jpg;base64,{image_base64[-1]}",
+                                },
                             },
-                        },
-                    ],
-                }
-            ],
-            model="meta-llama/llama-4-scout-17b-16e-instruct",
-            max_completion_tokens=50,
-            temperature = 1
-        )
-        response=chat_completion.choices[0].message.content
-        return response
-    else:
-        return ''
+                        ],
+                    }
+                ],
+                model="meta-llama/llama-4-scout-17b-16e-instruct",
+                max_completion_tokens=50,
+                temperature = 1
+            )
+            response=chat_completion.choices[0].message.content
+            return response
+        else:
+            return ''
         
+class AnalyticsViewer:
+    def __init__(self, business_details):
+        self.business_details = business_details
+        
+    def show_analytics(self):
+        try:
+            tool_response = InfluencerRetrievalTool().retrieve_for_analytics(str(self.business_details))
+            app_logger.info('Showing Analytics of the influencers after context analysis.')
+            return tool_response
+        except Exception as e:
+            error_logger.error(f'Error while showing analytics: {e}')
+            return e
 
-def show_analytics(business_details):
-    tool_response = retrieve_data_for_analytics(str(business_details))
-    app_logger.info('Showing Analytics of the influencers after context analysis.')
-    return tool_response
+class ResponseBlockExtractor:
+    def __init__(self, response):
+        self.response = response
 
-def extract_latest_response_block(response):
-    latest_block = []
-    temp_block = []
+    def extract_latest(self):
+        latest_block = []
+        temp_block = []
 
-    # Reverse iterate through the messages
-    for message in reversed(response):
-        if isinstance(message, (FunctionMessage, AIMessage)):
-            temp_block.insert(0, message.content)
+        # Reverse iterate through the messages
+        for message in reversed(self.response):
+            if isinstance(message, (FunctionMessage, AIMessage)):
+                temp_block.insert(0, message.content)
 
-            # Once we collect 3 items in correct structure, stop
-            if len(temp_block) == 3:
-                if "tool=" in temp_block[1] and "query_response" in temp_block[1]:
-                    latest_block = temp_block
-                    break
-                else:
-                    temp_block = []
-    print('The latest block', latest_block)
-    return latest_block
+                # Once we collect 3 items in correct structure, stop
+                if len(temp_block) == 3:
+                    if "tool=" in temp_block[1] and "query_response" in temp_block[1]:
+                        latest_block = temp_block
+                        break
+                    else:
+                        temp_block = []
+        print('The latest block', latest_block)
+        return latest_block