Implemented the workflow and integrated in fast api

.gitignore

@@ -0,0 +1,2 @@
+myenv
+.env

main.py

@@ -0,0 +1,19 @@
+from fastapi import FastAPI
+from pydantic import BaseModel
+from my_agent.agent import build_graph
+import pandas as pd
+
+app = FastAPI()
+graph = build_graph()
+
+# Optional: define input schema
+class RequestInput(BaseModel):
+    # query: list =[ "I want to make a promotional video of restaurant near lakeside"]
+    query: list 
+
+
+@app.post("/run")
+def run_graph(input_data: RequestInput):
+    result = graph.invoke({'topic' : input_data.query})
+    return {'returned_story': result['final_story']}
+    

my_agent/agent.py

@@ -0,0 +1,24 @@
+from langgraph.graph import StateGraph, START, END
+from .utils.state import State
+from .utils.nodes import retrieve, generate_story, generate_brainstroming , generate_final_story, route_after_selection, select_preferred_topics
+
+def build_graph():
+    builder = StateGraph(State)
+    builder.add_node(retrieve)
+    builder.add_node(generate_story)
+    builder.add_node(generate_brainstroming)
+    builder.add_node(select_preferred_topics)
+    builder.add_node(generate_final_story)
+
+
+    # Normal edges
+    builder.add_edge(START, "retrieve")
+    builder.add_edge("retrieve", "generate_story")
+    builder.add_edge("generate_story", "generate_brainstroming")
+    builder.add_edge("generate_brainstroming", "select_preferred_topics")
+
+    # Conditional edge
+    builder.add_conditional_edges("select_preferred_topics", route_after_selection,{True:'retrieve',False:'generate_final_story'})
+    builder.add_edge("generate_final_story",END)
+
+    return builder.compile()

my_agent/utils/data_loader.py

@@ -0,0 +1,9 @@
+from datasets import load_dataset
+
+def load_influencer_data():
+    dataset = load_dataset("subashdvorak/tiktok-agentic-story",revision="embedded")
+    data= dataset['train'].add_faiss_index('embeddings')
+    return data
+
+
+

my_agent/utils/models_loader.py

@@ -0,0 +1,27 @@
+
+from langchain_groq import ChatGroq
+from sentence_transformers import SentenceTransformer
+from huggingface_hub import login
+from dotenv import load_dotenv
+load_dotenv()
+import os
+from langchain_huggingface import HuggingFaceEndpoint
+os.environ['HUGGINGFACEHUB_ACCESS_TOKEN']=os.getenv('HUGGINGFACEHUB_ACCESS_TOKEN')
+login(os.environ['HUGGINGFACEHUB_ACCESS_TOKEN'])
+os.environ['GROQ_API_KEY']=os.getenv('GROQ_API_KEY')
+
+ST = SentenceTransformer("mixedbread-ai/mxbai-embed-large-v1")
+
+llm = ChatGroq(
+    model="llama3-8b-8192",
+    temperature=0,
+    max_tokens=None,
+    timeout=None,
+    max_retries=2,
+
+)
+
+
+
+
+

my_agent/utils/nodes.py

@@ -0,0 +1,160 @@
+import pandas as pd
+import ast
+from .state import State
+from .tools import StoryFormatter, BrainstromTopicFormatter
+from langchain_core.messages import SystemMessage
+from .models_loader import llm , ST
+from .data_loader import load_influencer_data
+
+
+def retrieve(state: State) -> State:
+  print('Moving to retrieval process')
+  retrievals=[]
+  for topic in state.topic:  # Loop through each topic
+      embedded_query = ST.encode(topic)  # Embed each topic
+      data = load_influencer_data()
+      scores, retrieved_examples = data.get_nearest_examples("embeddings", embedded_query, k=1)
+
+      # Construct a list of dictionaries for this topic
+      result = [{user: story} for user, story in zip(retrieved_examples['username'], retrieved_examples['agentic_story'])]
+      retrievals.append(result)
+      print('Retrieval process completed......')
+  state.retrievals.append(retrievals)
+
+  print('The retrieval is:\n',state.retrievals )
+  # return State(messages="Retrieved",topic=state.topic,retrievals=state.retrievals)
+  return state
+
+def generate_story(state:State)-> State:
+  topic=state.topic
+  print('The state retrieval is:',state.retrievals)
+  retrieval_list= state.retrievals[-1]
+  agentic_stories = []
+
+  for item in retrieval_list:
+      print('item:', item[-1].values())
+
+      agentic_stories.extend(item[-1].values())  # Add all stories to the list
+
+  retrieval = " ".join(agentic_stories)
+
+  if len(state.preferred_topics)==0:
+    template = f'''I want to create a detailed storyline for a video in any domain. You have to provide me that storyline what to include in the video.
+    Now, i am giving you the topic of the video. But the need is to generate the story focusing on the format that i'll provide to you.
+    You can use this format for the reference purpose, not for the exact similar generation. Th format is:\n{retrieval}.
+    \n\n Now let's start creating the storyline for my topic. The topic of the video is: \n\n{state.topic}'''
+  else:
+    template = f'''I want to create a detailed storyline for a video in the given topic. You have to provide me that storyline what to include in the video.
+  Now, i am giving you the topic of the video. But the need is to generate the story focusing on the format that i'll provide to you.
+  You can use this format for the reference purpose, not for the exact similar generation. The format is:\n{retrieval}.
+  \n\n Now let's start creating the storyline for my topic. The topic of the video is: \n\n{state.topic}\n\n
+
+  **Final Reminder** You have to strongly focus on these topics while creating the storyline: {state.preferred_topics[-1]}'''
+
+
+  messages = [SystemMessage(content=template)]
+  response = llm.bind_tools([StoryFormatter]).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"
+  state.stories.append(response)
+  # return State(messages="Story generated", topic=state.topic,stories=state.stories)
+  return state
+
+
+
+def generate_brainstroming(state:State)-> State:
+  story=state.stories[-1]
+
+  template= f'''I want to brainstorm ways to diversify or improve a storyline in exactly 4 sentences.
+The goal is to generate creative and actionable ideas that are not on the storyline on how the storyline can be expanded or modified for better engagement.
+For example: If the storyline is about creating a promotional video for a restaurant, the new suggestions might include:
+- I want to showcase the chef preparing a signature dish.
+- I want to add a sequence of customers sharing their experiences at the restaurant.
+- I want to highlight the farm-to-table sourcing of ingredients with a short segment showing local farms.
+- I want to include a time-lapse of the restaurant transforming from day to night, capturing its unique ambiance.
+- I want to feature a quick interview with the owner sharing the story behind the restaurant.
+Now, I will provide you with the storyline. The storyline is:\n{story}'''
+
+  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"
+
+  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)
+  return state
+
+
+
+def select_preferred_topics(state: State)-> State:
+    print("---human_feedback---")
+
+    topic_values = list(state.brainstroming_topics[-1].values())
+
+    print("Available topics:")
+    for idx, topic in enumerate(topic_values, 1):
+        print(f"{idx}. {topic}")
+
+    raw_input_str = input("Enter the numbers of your preferred topics (comma-separated), or press Enter to skip: ").strip()
+
+    if not raw_input_str:
+        state.carry_on=False
+        print("No topics selected. Ending process.")
+        return state
+
+    try:
+        preferred_indices = [int(i.strip()) for i in raw_input_str.split(",")]
+        preferred_topics = [topic_values[i - 1] for i in preferred_indices if 0 < i <= len(topic_values)]
+        state.preferred_topics.append(preferred_topics)
+    except Exception:
+        state.carry_on=False
+        print("Invalid input. Please try again.")
+        return state
+
+    if not preferred_topics:
+        state.carry_on=False
+        print("No valid topics selected. Ending process.")
+        return state
+
+    print("You selected:")
+    print(preferred_topics)
+    state.carry_on=True
+    return state
+
+
+def generate_final_story(state:State)-> State:
+    template = f'''I want to create a detailed storyline for a video in the given topic. You have to provide me that storyline what to include in the video.
+  Now, i am giving you the topic of the video. But the need is to generate the story focusing on the format that i'll provide to you.
+  You can use this format for the reference purpose, not for the exact similar generation. The format is:\n{state.retrievals[-1]}.
+  \n\n Now let's start creating the storyline for my topic. The topic of the video is: \n\n{state.topic}\n\n
+
+  **Final Reminder** You have to strongly focus on these topics while creating the storyline: {[item for sublist in state.preferred_topics for item in sublist]}'''
+    messages = [SystemMessage(content=template)]
+    response = llm.bind_tools([StoryFormatter]).invoke(messages)
+    print('The final 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"
+    state.final_story=response
+    state.stories.append(response)
+    return state
+
+
+
+def route_after_selection(state:State):
+    print('The output is:',state.carry_on)
+    return state.carry_on

my_agent/utils/state.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel, ConfigDict
+from typing import Optional
+import pandas as pd
+
+class State(BaseModel):
+    carry_on: Optional[bool]=False
+    messages: Optional[str] = None
+    topic: list
+    brainstroming_topics: Optional[list] = []
+    preferred_topics: Optional[list] = []
+    stories : Optional[list]=[]
+    final_story: Optional[str]=None
+    retrievals : Optional[list]=[]
+    model_config = ConfigDict(arbitrary_types_allowed=True)

my_agent/utils/tools.py

@@ -0,0 +1,34 @@
+from langchain_core.messages import SystemMessage
+from langchain_groq import ChatGroq
+from pydantic import BaseModel, Field
+from dotenv import load_dotenv
+load_dotenv()
+import os
+import numpy as np
+
+os.environ['GROQ_API_KEY']=os.getenv('GROQ_API_KEY')
+
+llm = ChatGroq(
+    model="llama3-8b-8192",
+    temperature=0,
+    max_tokens=None,
+    timeout=None,
+    max_retries=2,
+
+)
+
+class StoryFormatter(BaseModel):
+    """Always use this tool to structure your response to the user."""
+    story: str=Field(description="How to introduce the scene and set the tone. What is happening in the scene? Describe key visuals and actions")
+    narration:str=Field(description="Suggestions for narration or voiceover that complements the visuals." )
+    text_in_the_Video:str=Field(description="Propose important text overlays for key moments.")
+    transitions:str=Field(description="Smooth transitions between scenes to maintain flow.")
+    emotional_tone:str=Field(description="The mood and energy of the scenes (e.g., excitement, calm, tension, joy")
+    key_visuals:str=Field(description="Important props, locations, sound effects, or background music to enhance the video.")
+
+
+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")

requirements.txt

@@ -0,0 +1,12 @@
+langgraph 
+langsmith 
+langchain_groq
+pydantic 
+datasets 
+faiss-cpu
+dotenv
+fastapi
+uvicorn
+numpy 
+pandas
+langchain_huggingface