moving to a graph

agents.py

@@ -3,55 +3,6 @@ from operator import itemgetter
 from langchain_core.runnables.passthrough import RunnablePassthrough
 import models
 import prompts
-import tools
-
-search_agent = create_team_agent(
-    models.gpt4o,
-    [tools.tavily_tool],
-    "You are a research assistant who can search for up-to-date info using the tavily search engine.",
-    "Search",
-    ["Search", "PaperInformationRetriever"]
-)
-
-research_agent = create_team_agent(
-    models.gpt4o,
-    [tools.retrieve_information],
-    "You are a research assistant who can provide specific information on the provided paper: 'murthy-loneliness.pdf'. You must only respond with information about the paper related to the request.",
-    "PaperInformationRetriever",
-    ["Search", "PaperInformationRetriever"]
-)
-
-doc_writer_agent = create_team_agent(
-    models.gpt4o,
-    [tools.write_document, tools.edit_document, tools.read_document],
-    "You are an expert writing technical social media posts.",
-    "DocWriter",
-    ["DocWriter", "NoteTaker", "CopyEditor", "VoiceEditor"]
-)
-
-note_taking_agent = create_team_agent(
-    models.gpt4o,
-    [tools.create_outline, tools.read_document],
-    "You are an expert senior researcher tasked with writing a social media post outline and taking notes to craft a social media post.",
-    "NoteTaker",
-    ["DocWriter", "NoteTaker", "CopyEditor", "VoiceEditor"]
-)
-
-copy_editor_agent = create_team_agent(
-    models.gpt4o,
-    [tools.write_document, tools.edit_document, tools.read_document],
-    "You are an expert copy editor who focuses on fixing grammar, spelling, and tone issues.",
-    "CopyEditor",
-    ["DocWriter", "NoteTaker", "CopyEditor", "VoiceEditor"]
-)
-
-voice_editor_agent = create_team_agent(
-    models.gpt4o,
-    [tools.write_document, tools.edit_document, tools.read_document],
-    "You are an expert in crafting and refining the voice and tone of social media posts. You edit the document to ensure it has a consistent, professional, and engaging voice appropriate for social media platforms.",
-    "VoiceEditor",
-    ["DocWriter", "NoteTaker", "CopyEditor", "VoiceEditor"]
-)
 
 simple_rag_chain = (
         {

app.py

@@ -2,6 +2,7 @@ import chainlit as cl
 from helper_functions import process_file, load_documents_from_url
 import models
 import agents
+import graph
 import asyncio
 
 @cl.on_chat_start
@@ -54,8 +55,10 @@ async def main(message: cl.Message):
         await handle_response(res)
     else:
         # Handle the question as usual
-        await cl.Message(content="Thinking about it, give me a second...", disable_human_feedback=True).send()
-        response = await asyncio.to_thread(retrieval_augmented_qa_chain.invoke, {"question": message.content})
+        await cl.Message(content="Our specialist is working...", disable_human_feedback=True).send()
+        #response = await asyncio.to_thread(retrieval_augmented_qa_chain.invoke, {"question": message.content})
+        response = await asyncio.to_thread(graph.getSocialMediaPost,  message.content)
+        print(response)
         await cl.Message(content=response.content).send()
         res = await ask_action()
         await handle_response(res)

graph.py

@@ -1,33 +1,35 @@
-from typing import Dict, List, TypedDict, Annotated, Sequence
-from langgraph.graph import Graph, StateGraph, END
-from langgraph.prebuilt import ToolExecutor
+from typing import Dict, List, TypedDict, Sequence
+from langgraph.graph import StateGraph, END
 from langchain.schema import StrOutputParser
 from langchain.schema.runnable import RunnablePassthrough
 from langchain_community.tools.tavily_search import TavilySearchResults
 import models
 import prompts
-from helper_functions import format_docs
+import json
 from operator import itemgetter
+from langgraph.errors import GraphRecursionError
 
-# Define the state structure
-class State(TypedDict):
-    messages: Sequence[str]
+
+#######################################
+###     Research Team Components    ###
+#######################################
+class ResearchState(TypedDict):
+    workflow: List[str]
     topic: str
     research_data: Dict[str, str]
-    team_members: List[str]
-    draft_posts: Sequence[str]
-    final_post: str
+    next: str
+    message_to_manager: str
+    message_from_manager: str
 
-
-research_members = ["Qdrant_researcher", "Web_researcher"]
-# Research Agent Pieces
+#
+#   Reserach Chains and Tools
+#
 qdrant_research_chain = (
         {"context": itemgetter("topic") | models.compression_retriever, "topic": itemgetter("topic")}
         | RunnablePassthrough.assign(context=itemgetter("context"))
         | {"response": prompts.research_query_prompt  | models.gpt4o_mini | StrOutputParser(), "context": itemgetter("context")}
     )
 
-# Web Search Agent Pieces
 tavily_tool = TavilySearchResults(max_results=3)
 query_chain = ( prompts.search_query_prompt | models.gpt4o_mini | StrOutputParser() )
 tavily_simple = ({"tav_results": tavily_tool} | prompts.tavily_prompt | models.gpt4o_mini | StrOutputParser())
@@ -35,133 +37,304 @@ tavily_chain = (
     {"query": query_chain} | tavily_simple
 )
 
-def query_qdrant(state: State) -> State:
-    # Extract the last message as the input
-    topic = state["topic"]
+research_supervisor_chain = (
+    prompts.research_supervisor_prompt | models.gpt4o | StrOutputParser()
+)
 
-    # Run the chain
+#
+#   Reserach Node Defs
+#
+def query_qdrant(state: ResearchState) -> ResearchState:
+    #print("qdrant node")
+    topic = state["topic"]
     result = qdrant_research_chain.invoke({"topic": topic})
-
-    # Update the state with the research results
-    state["research_data"]["qdrant_results"] = result
+    #print(result)
+    state["research_data"]["qdrant_results"] = result["response"]
+    state['workflow'].append("query_qdrant")
+    #print(state['workflow'])
 
     return state
 
-def web_search(state: State) -> State:
+def web_search(state: ResearchState) -> ResearchState:
+    #print("tavily node")
     # Extract the last message as the topic
     topic = state["topic"]
-    
+    #print(topic)
     # Get the Qdrant results from the state
     qdrant_results = state["research_data"].get("qdrant_results", "No previous results available.")
-    
     # Run the web search chain
     result = tavily_chain.invoke({
         "topic": topic,
         "qdrant_results": qdrant_results
     })
-    
+    #print(result)
     # Update the state with the web search results
     state["research_data"]["web_search_results"] = result
-    
+    state['workflow'].append("web_search")
+    #print(state['workflow'])
     return state
 
 def research_supervisor(state):
-    # Implement research supervision logic
+    #print("research supervisor node")
+    message_from_manager = state["message_from_manager"]
+    collected_data = state["research_data"]
+    topic = state['topic']
+    supervisor_result = research_supervisor_chain.invoke({"message_from_manager": message_from_manager, "collected_data": collected_data, "topic": topic})
+    lines = supervisor_result.split('\n')
+    #print(supervisor_result)
+    for line in lines:
+        if line.startswith('Next Action: '):
+            state['next'] = line[len('Next Action: '):].strip()  # Extract the next action content
+        elif line.startswith('Message to project manager: '):
+            state['message_to_manager'] = line[len('Message to project manager: '):].strip()
+    state['workflow'].append("research_supervisor")
+    #print(state['workflow'])
     return state
 
-def post_creation(state):
-    # Implement post creation logic
+def research_end(state):
+    #print("research_end node")
+    state['workflow'].append("research_end")
+    #print(state['workflow'])
     return state
 
-def copy_editing(state):
-    # Implement copy editing logic
+#######################################
+###     Writing Team Components     ###
+#######################################
+class WritingState(TypedDict):
+    workflow: List[str]
+    topic: str
+    research_data: Dict[str, str]
+    draft_posts: Sequence[str]
+    final_post: str
+    next: str
+    message_to_manager: str
+    message_from_manager: str
+    review_comments: str
+    style_checked: bool
+
+#
+#   Writing Chains
+#
+writing_supervisor_chain = (
+    prompts.writing_supervisor_prompt | models.gpt4o | StrOutputParser()
+)
+
+post_creation_chain = (
+    prompts.post_creation_prompt | models.gpt4o_mini | StrOutputParser()
+)
+
+post_editor_chain = (
+	prompts.post_editor_prompt | models.gpt4o | StrOutputParser()
+)
+
+post_review_chain = (
+	prompts.post_review_prompt | models.gpt4o | StrOutputParser()
+)
+
+#
+#   Writing Node Defs
+#
+def post_creation(state):
+    print("post_creation node")
+    topic = state['topic']
+    drafts = state['draft_posts']
+    collected_data = state["research_data"]
+    review_comments = state['review_comments']
+    results = post_creation_chain.invoke({"topic": topic, "collected_data": collected_data, "drafts": drafts, "review_comments": review_comments})
+    state['draft_posts'].append(results)
+    state['workflow'].append("post_creation")
     return state
 
-def voice_editing(state):
-    # Implement voice editing logic
+def post_editor(state):
+    print("post_editor node")
+    current_draft = state['draft_posts'][-1]
+    styleguide = prompts.style_guide_text
+    review_comments = state['review_comments']
+    results = post_editor_chain.invoke({"current_draft": current_draft, "styleguide": styleguide, "review_comments": review_comments})
+    state['draft_posts'].append(results)
+    state['workflow'].append("post_editor")
     return state
 
 def post_review(state):
-    # Implement post review logic
+    print("post_review node")
+    current_draft = state['draft_posts'][-1]
+    styleguide = prompts.style_guide_text
+    results = post_review_chain.invoke({"current_draft": current_draft, "styleguide": styleguide})
+    data = json.loads(results.strip())
+    state['review_comments'] = data["Comments on current draft"]
+    if data["Draft Acceptable"] == 'Yes':
+        state['final_post'] = state['draft_posts'][-1]
+    state['workflow'].append("post_review")
+    return state
+
+def writing_end(state):
+    print("writing_end node")
+    state['workflow'].append("writing_end")
+    print(state['workflow'])
     return state
 
 def writing_supervisor(state):
-    # Implement writing supervision logic
+    print("writing_supervisor node")
+    message_from_manager = state['message_from_manager']
+    topic = state['topic']
+    drafts = state['draft_posts']
+    final_draft = state['final_post']
+    review_comments = state['review_comments']
+    supervisor_result = writing_supervisor_chain.invoke({"review_comments": review_comments, "message_from_manager": message_from_manager, "topic": topic, "drafts": drafts, "final_draft": final_draft})
+    lines = supervisor_result.split('\n')
+    print(supervisor_result)
+    for line in lines:
+        if line.startswith('Next Action: '):
+            state['next'] = line[len('Next Action: '):].strip()  # Extract the next action content
+        elif line.startswith('Message to project manager: '):
+            state['message_to_manager'] = line[len('Message to project manager: '):].strip()
+    state['workflow'].append("writing_supervisor")
     return state
 
+#######################################
+###  Overarching Graph Components   ###
+#######################################
+class State(TypedDict):
+    workflow: List[str]
+    topic: str
+    research_data: Dict[str, str]
+    draft_posts: Sequence[str]
+    final_post: str
+    next: str
+    user_input: str
+    message_to_manager: str
+    message_from_manager: str
+    last_active_team :str
+    next_team: str
+    review_comments: str
+
+#
+#   Complete Graph Chains
+#
+overall_supervisor_chain = (
+    prompts.overall_supervisor_prompt | models.gpt4o | StrOutputParser()
+)
+
+#
+#   Complete Graph Node defs
+#
 def overall_supervisor(state):
+    print("overall supervisor node")
     # Implement overall supervision logic
+    init_user_query = state["user_input"]
+    message_to_manager = state['message_to_manager']
+    last_active_team = state['last_active_team']
+    supervisor_result = overall_supervisor_chain.invoke({"query": init_user_query, "message_to_manager": message_to_manager, "last_active_team": last_active_team})
+    lines = supervisor_result.split('\n')
+    print(supervisor_result)
+    for line in lines:
+        if line.startswith('Next Action: '):
+            state['next_team'] = line[len('Next Action: '):].strip()  # Extract the next action content
+        elif line.startswith('Extracted Topic: '):
+            state['topic'] = line[len('Extracted Topic: '):].strip()  # Extract the next action content
+        elif line.startswith('Message to supervisor: '):
+            state['message_from_manager'] = line[len('Message to supervisor: '):].strip()  # Extract the next action content
+    state['workflow'].append("overall_supervisor")
+    print(state['next_team'])
+    print(state['workflow'])
     return state
 
-# Create the research team graph
-research_graph = StateGraph(State)
+#######################################
+###         Graph structures        ###
+#######################################
 
+#
+#   Reserach Graph Nodes
+#
+research_graph = StateGraph(ResearchState)
 research_graph.add_node("query_qdrant", query_qdrant)
 research_graph.add_node("web_search", web_search)
 research_graph.add_node("research_supervisor", research_supervisor)
-
+research_graph.add_node("research_end", research_end)
+#
+#   Reserach Graph Edges
+#
+research_graph.set_entry_point("research_supervisor")
 research_graph.add_edge("query_qdrant", "research_supervisor")
 research_graph.add_edge("web_search", "research_supervisor")
 research_graph.add_conditional_edges(
     "research_supervisor",
     lambda x: x["next"],
-    {"query_qdrant": "query_qdrant", "web_search": "web_search", "FINISH": END},
+    {"query_qdrant": "query_qdrant", "web_search": "web_search", "FINISH": "research_end"},
 )
-#research_graph.add_edge("research_supervisor", END)
-
-research_graph.set_entry_point("research_supervisor")
 research_graph_comp = research_graph.compile()
 
-# Create the writing team graph
-writing_graph = StateGraph(State)
-
+#
+#   Writing Graph Nodes
+#
+writing_graph = StateGraph(WritingState)
 writing_graph.add_node("post_creation", post_creation)
-writing_graph.add_node("copy_editing", copy_editing)
-writing_graph.add_node("voice_editing", voice_editing)
+writing_graph.add_node("post_editor", post_editor)
 writing_graph.add_node("post_review", post_review)
 writing_graph.add_node("writing_supervisor", writing_supervisor)
-
-writing_graph.add_edge("post_creation", "writing_supervisor")
-writing_graph.add_edge("copy_editing", "writing_supervisor")
-writing_graph.add_edge("voice_editing", "writing_supervisor")
+writing_graph.add_node("writing_end", writing_end)
+#
+#   Writing Graph Edges
+#
+writing_graph.set_entry_point("writing_supervisor")
+writing_graph.add_edge("post_creation", "post_editor")
+writing_graph.add_edge("post_editor", "post_review")
 writing_graph.add_edge("post_review", "writing_supervisor")
 writing_graph.add_conditional_edges(
     "writing_supervisor",
     lambda x: x["next"],
-    {"post_creation": "post_creation", 
-     "copy_editing": "copy_editing",
-     "voice_editing": "voice_editing",
-     "post_review": "post_review",
-     "FINISH": END},
+    {"NEW DRAFT": "post_creation", 
+     "FINISH": "writing_end"},
 )
-#writing_graph.add_edge("writing_supervisor", END)
-
-writing_graph.set_entry_point("writing_supervisor")
+writing_graph_comp = writing_graph.compile()
 
-writing_graph_comp = research_graph.compile()
-
-# Create the overall graph
+#
+#   Complete Graph Nodes
+#
 overall_graph = StateGraph(State)
-
-# Add the research and writing team graphs as nodes
-overall_graph.add_node("research_team", research_graph)
-overall_graph.add_node("writing_team", writing_graph)
-
-# Add the overall supervisor node
 overall_graph.add_node("overall_supervisor", overall_supervisor)
-
+overall_graph.add_node("research_team_graph", research_graph_comp)
+overall_graph.add_node("writing_team_graph", writing_graph_comp)
+#
+#   Complete Graph Edges
+#
 overall_graph.set_entry_point("overall_supervisor")
-
-# Connect the nodes
-overall_graph.add_edge("research_team", "overall_supervisor")
-overall_graph.add_edge("writing_team", "overall_supervisor")
+overall_graph.add_edge("research_team_graph", "overall_supervisor")
+overall_graph.add_edge("writing_team_graph", "overall_supervisor")
 overall_graph.add_conditional_edges(
     "overall_supervisor",
-    lambda x: x["next"],
-    {"research_team": "research_team", 
-     "writing_team": "writing_team",
+    lambda x: x["next_team"],
+    {"research_team": "research_team_graph",
+     "writing_team": "writing_team_graph", 
      "FINISH": END},
 )
+app = overall_graph.compile()
 
-# Compile the graph
-app = overall_graph.compile()
+
+#######################################
+###         Run method              ###
+#######################################
+
+def getSocialMediaPost(userInput: str) -> str:
+    finalPost = ""
+    initial_state = State(
+        workflow = [],
+        topic= "",
+        research_data = {},
+        draft_posts = [],
+        final_post = [],
+        next = [],
+        next_team = [],
+        user_input=userInput,
+        message_to_manager="",
+        message_from_manager="",
+        last_active_team="",
+        review_comments=""
+    )
+    results = app.invoke(initial_state)
+    try:
+        results = app.invoke(initial_state, {"recursion_limit": 3})
+    except GraphRecursionError:
+        return "Recursion Error"
+    finalPost = results.final_post
+    return finalPost

helper_functions.py

@@ -80,7 +80,9 @@ def add_to_qdrant(documents, embeddings, qdrant_client, collection_name):
 
 def agent_node(state, agent, name):
     result = agent.invoke(state)
-    return {"messages": [HumanMessage(content=result["output"], name=name)]}
+    return {
+        "messages": [HumanMessage(content=result["messages"][-1].content, name=name)]
+    }
 
 def create_team_agent(llm, tools, system_prompt, agent_name, team_members):
     return create_agent(

models.py

@@ -122,10 +122,11 @@ qdrant_client = QdrantClient(url=constants.QDRANT_ENDPOINT, api_key=constants.QD
 #    collection_name="docs_from_ripped_urls_recursive",
 #    embedding=te3_small
 #)
+collection_name="docs_from_ripped_urls_semantic_tuned"
 
 semantic_tuned_Qdrant_vs = QdrantVectorStore(
     client=qdrant_client,
-    collection_name="docs_from_ripped_urls_semantic_tuned",
+    collection_name=collection_name,
     embedding=tuned_embeddings
 )
 

prompts.py

@@ -37,14 +37,17 @@ Answer:
 )
 
 search_query_prompt = ChatPromptTemplate.from_template(
-    """Given the following topic and information from our database, create a search query to find supplementary information:
+    """Given the following topic and information from our database, create a search query to find supplementary information about the topic, including facts, statistics, surveys, articles, and quotes:
 
     Topic: {topic}
     
     Information from our database:
     {qdrant_results}
     
-    Generate a search query to find additional, up-to-date information that complements what we already know:
+    Generate a search query to find additional, up-to-date information that complements what we already know. Only include the query you generate, do not include any extraneous language.
+
+    Output:
+    Query
     """
 )
 
@@ -61,3 +64,154 @@ tavily_prompt = ChatPromptTemplate.from_template(
     ...
     """
 )
+
+research_supervisor_prompt = ChatPromptTemplate.from_template(
+    """You are the supervisor of a team of researchers with different roles. 
+    
+    Your team's task is to collect information about a given topic.
+
+    As you are the supervisor, you must determine which of your team members should perform their task next.
+
+    Your team members include 'query_qdrant', which can search a database of information that will relate to the topic, and 'web_search', which can search the wider internet for more information about the topic not contained in our database.
+
+    The available actions are the names of your team members (to indicate which team member should run next), or 'FINISH' to indicate that sufficient data has been collected about the topic, and you wish to send your team's work back to your own supervisor.
+
+    You will have access to the data that the team has collected so far, if any exists. You will use this to determine if any further collection is needed.
+
+    You can send a specific message or request to your supervisor when your next action is to send it back to them. When you are called to perform your own task by the project manager, they may have a helpful message or request of you.
+
+    Message from project manager: {message_from_manager}
+    Topic: {topic}
+    Data collected so far: {collected_data}
+
+    Output: 
+    Next Action: ...
+    Message to project manager: ...
+    """
+)
+
+overall_supervisor_prompt = ChatPromptTemplate.from_template(
+    """You are the project manager of two teams who are working to create factually accurate and emotionally meaningful social media posts regarding emotional health in the workplace.
+    
+    Your task is to coordinate the two teams. The first team, 'research_team', is tasked with collecting information and data about the specific topic that the user asks about. The second team, 'writing_team', will use that collected data and information to generaete posts, and then review and iterate over them until the post is of sufficient quality.
+    Each team is headed by its own supervisor, who will manage the individual members of that team.
+
+    As you are the project manager, you will deal directly with the user and their initial query, so if there is not an existing topic that has been extracted from the user's query, you must analyze the query and determine what topic your team will be dealing with.
+
+    After determining the topic, or if a specific topic has already been supplied, you must determine which of the teams should perform their task next.
+
+    The available actions are the names of your teams (to indicate which team should run next), or 'FINISH' to indicate that a sufficient quality social media post is ready to share with the user.
+
+    To help you determine which team should run next, or if the post is ready to share with the user, you will have access to the latest team supervisor requests and messages, as well as a flag indicating which team was most recently active.
+
+    If you have to pass along a message to the next team, such as if the writing team had asked that the research team collect more information, or if you want to give specific direction to a supervisor, you can do so.
+
+    User query: {query}
+    Team message: {message_to_manager}
+    Last active team: {last_active_team}
+
+    Output: 
+    Extracted Topic: ...
+    Next Action: ...
+    Message to supervisor: ...
+    """
+)
+
+writing_supervisor_prompt = ChatPromptTemplate.from_template(
+    """You are the supervisor of a team of writers and editors. 
+    
+    Your team's task is to construct a high quality draft of a social media post about the topic, using information and data that has been compiled for you.
+
+    Your team members include:
+    1) 'post_creation' - This team member is in charge of using the collected data to draft the initial social media posts.
+    2) 'post_editor' - This team member takes the latest draft and ensures that it fits the tone and style requirements set by a writing guide, editting the post if required.
+    3) 'post_review' - This team member reviews the latest draft, ensuring all quality checks are met, sources are present, and determines if it meets the standards of the final post.
+
+    Your available actions are 'NEW DRAFT' to indicate that you want your team to compile a new draft post, or 'FINISH' to indicate that a sufficient final post has been created, and you wish to send your team's work back to your own supervisor.
+
+    You will have access to drafts that your team has created so far, as well as the final draft, if either exist. You will use the presence of the final post to determine if your team is finished. If you do not have a final post given to you, you cannot turn your team's work in to your supervisor.
+
+    You will also be given the latest comments from the post_review team member regarding the current status of the draft, including if anything needs changed or not. 
+
+    If you do not have a final post given to you, you cannot turn your team's work in to your supervisor.
+
+    You can send a specific message or request to your supervisor when your next action is to send it back to them. When you are called to perform your own task by the project manager, they may have a helpful message or request of you.
+
+    Message from project manager: {message_from_manager}
+    Topic: {topic}
+    Drafts so far: {drafts}
+    Final Post: {final_draft}
+    Comments from Reviewer: {review_comments}
+
+    Output: 
+    Next Action: ...
+    Message to project manager: ...
+    """
+)
+
+post_creation_prompt = ChatPromptTemplate.from_template(
+    """You are a writer on a team tasked with creating professional social media posts about mental health in the workplace.
+
+    You are tasked with creating drafts of posts that a marketing team can use either as they are, or as bases for posts on various social media sites.
+
+    You will be given a set of collected data and information that are related to the market team's current post idea, including but not limited to facts, statistics, quotes, articles, surveys, etc. This data will include sources.
+
+    You will also be given a set of previous drafts of the post, if any exist, so that you can iterate and improve on what was created previously, as well as the latest set of comments from the post_review team member, if there are any. These comments will help you improve over previous drafts.
+
+    The previous review comments will outline what was satisfactory about the last draft and what was not satisfactory. Take the comments into account to ensure that you do not make the same mistakes on the current draft.
+
+    Using the data, write a draft of a social media post about the topic. Do not make up new facts or data to base your post on, use only the data provided. Where possible, also include the source of the information you use in the post.
+
+    Topic: {topic}
+    Drafts so far: {drafts}
+    Collected data: {collected_data}
+    Comments from previous review: {review_comments}
+
+    Output:
+    (Draft post)
+    """
+)
+
+post_editor_prompt = ChatPromptTemplate.from_template(
+    """You are a writer on a team tasked with creating professional social media posts about mental health in the workplace.
+
+    You are tasked with ensuring that a current draft of a social media post follows your organization's style, tone, and voice guidelines as dictated by a style guide. 
+
+    You will be given the current draft of the post, the organization's writing style guide to review, and any comments from the previous draft's review.
+
+    The previous review comments will outline what was satisfactory about the last draft and what was not satisfactory. Take the comments into account to ensure that you do not make the same mistakes on the current draft.
+
+    You are to rewrite the draft post, if required, to adhere the writing style and professional expectations outlined in the style guide. You **MUST** adhere to the style guide.
+    The underlying message and content of the post should remain unchanged. All factual information, quotes, or sources included in the post should be included in the rewrite.
+
+    Your output should not include any of your supplementary comments.
+
+    Current draft: {current_draft}
+    Style guide: {styleguide}
+    Comments from previous review: {review_comments}
+
+    Output:
+    (Updated draft)
+    """
+)
+
+post_review_prompt = ChatPromptTemplate.from_template(
+    """You are a writer on a team tasked with creating professional social media posts about mental health in the workplace.
+
+    You are tasked with determining if a current draft social media post is of sufficient quality to become the final draft.
+
+    You will be given the current draft of the post, and the organization's writing style guide.
+
+    Checking the draft's spelling and grammar, as well as the sentence strucutre, tone, and style against the writing guide, determine if the current draft of the post is acceptable.
+    If it is not, please give your reasoning why, and what should be changed.
+
+    Current draft: {current_draft}
+    Style guide: {styleguide}
+
+    Your output should be a json object in the follwoing format, but should **not** include the triple backticks or the 'json' label:
+    {{
+        "Draft Acceptable": (Yes/No),
+        "Comments on current draft": (comments)
+    }}
+    """
+)