renamed the essay_writer.py file to app.py

.env

@@ -1,3 +1,3 @@
 COHERE_API_KEY=p9Qnpw98wKgjWBBgiCW3JWBmskTkd6AL3kkutDYA
 TAVILY_API_KEY=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
-PORT1=8000
+#PORT1=8000

app.py

@@ -0,0 +1,253 @@
+import os
+from dotenv import load_dotenv
+from langgraph.graph import StateGraph, END
+from langgraph.checkpoint.sqlite import SqliteSaver
+from typing import List, TypedDict, Annotated
+from langchain_core.messages import (AnyMessage,
+                                     SystemMessage,
+                                     HumanMessage,
+                                     ToolMessage,
+                                     AIMessage )
+from langchain_cohere import ChatCohere
+from tavily import TavilyClient
+from pydantic import BaseModel
+
+_ = load_dotenv()
+
+CO_API_KEY = os.getenv("COHERE_API_KEY")
+TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")
+
+cohere_model = "command-a-03-2025"
+
+"""##### We will build an Agent to write an essay by following the steps depicted 
+         in the graph below:
+
+<img src="Essay_Writer_Graph.JPG">
+"""
+
+
+class AgentState(TypedDict):
+    task: str   # This is what we are trying to write the essay about
+    plan: str   # The plan that the planning agent will generate
+    draft: str  # Draft of the essat
+    critique: str  # Critique Agent will populate this key
+    content: List[str]  # List of documents that Tavili has researched.
+    revision_number: int
+    max_revisions: int
+
+
+model = ChatCohere(
+    api_key=CO_API_KEY,
+    model=cohere_model,
+)
+
+# This is the prompt for the LLM that will write the plan
+PLAN_PROMPT = """You are an expert writer tasked with writing a high level outline of an essay. \
+Write such an outline for the user provided topic. Give an outline of the essay along with any relevant notes \
+or instructions for the sections."""
+
+# This is the prompt for the LLM that will write the essay based on the
+# researched content
+WRITER_PROMPT = """You are an essay assistant tasked with writing excellent 5-paragraph essays.\
+Generate the best essay possible for the user's request and the initial outline. \
+If the user provides critique, respond with a revised version of your previous attempts. \
+Utilize all the information below as needed:
+
+------
+
+{content}"""
+
+# The Reflection prompt will be used to cretique the essay
+REFLECTION_PROMPT = """You are a teacher grading an essay submission. \
+Generate critique and recommendations for the user's submission. \
+Provide detailed recommendations, including requests for length, depth, style, etc."""
+
+# This is the prompt for Researching after the planning step
+# Given a plan we will generate a bunch of queries and pass it to the Tivili for
+# Research
+RESEARCH_PLAN_PROMPT = """You are a researcher charged with providing information that can \
+be used when writing the following essay. Generate a list of search queries that will gather \
+any relevant information. Only generate 3 queries max."""
+
+# This is a prompt that will generate new questions for Tivili baseds on the
+# critique of the research. This set of questions is based in the critiques, not
+# to be confused with the planning prompt which serves a similar purpose.
+RESEARCH_CRITIQUE_PROMPT = """You are a researcher charged with providing information that can \
+be used when making any requested revisions (as outlined below). \
+Generate a list of search queries that will gather any relevant information. Only generate 3 queries max."""
+
+
+class Queries(BaseModel):
+    queries: List[str]
+
+
+tavily = TavilyClient(api_key=TAVILY_API_KEY)
+
+
+# Define the planning node. Prompt the LLM to develop a "plan"
+def plan_node(state: AgentState):
+    messages = [
+        SystemMessage(content=PLAN_PROMPT),
+        HumanMessage(content=state['task'])
+    ]
+    response = model.invoke(messages)
+    return {"plan": response.content}
+
+
+def research_plan_node(state: AgentState):
+    queries = model.with_structured_output(Queries).invoke([
+        SystemMessage(content=RESEARCH_PLAN_PROMPT),
+        HumanMessage(content=state['task'])
+    ])
+    #content = state['content'] or []
+    content = state.get('content', [])
+    for q in queries.queries:
+        response = tavily.search(query=q, max_results=2)
+        for r in response['results']:
+            content.append(r['content'])
+    return {"content": content}
+
+
+# Generation node will write the first and subsequent drafts
+def generation_node(state: AgentState):
+    #content = "\n\n".join(state['content'] or [])
+    content = "\n\n".join(state.get('content', []))
+    user_message = HumanMessage(
+        content=f"{state['task']}\n\nHere is my plan:\n\n{state['plan']}")
+    messages = [
+        SystemMessage(content=WRITER_PROMPT.format(content=content)),
+        user_message
+        ]
+    response = model.invoke(messages)
+    return {
+        "draft": response.content,
+        "revision_number": state.get("revision_number", 1) + 1
+    }
+
+
+def reflection_node(state: AgentState):
+    messages = [
+        SystemMessage(content=REFLECTION_PROMPT),
+        HumanMessage(content=state['draft'])
+    ]
+    response = model.invoke(messages)
+    return {"critique": response.content}
+
+# def research_critique_node(state: AgentState):
+#     queries = model.with_structured_output(Queries).invoke([
+#         SystemMessage(content=RESEARCH_CRITIQUE_PROMPT),
+#         HumanMessage(content=state['critique'])
+#     ])
+#     #content = state['content'] or []
+#     content = state.get('content', [])
+#     for q in queries.queries:
+#         response = tavily.search(query=q, max_results=2)
+#         for r in response['results']:
+#             content.append(r['content'])
+#     return {"content": content}
+
+
+# We should only send a HumanMessage(content=state['critique']) if
+# state['critique'] is not empty.
+def research_critique_node(state: AgentState):
+    if not state.get('critique'):
+        # Skip if there is no critique yet
+        return {}
+
+    queries = model.with_structured_output(Queries).invoke([
+        SystemMessage(content=RESEARCH_CRITIQUE_PROMPT),
+        HumanMessage(content=state['critique'])
+    ])
+    content = state['content'] or []
+    for q in queries.queries:
+        response = tavily.search(query=q, max_results=2)
+        for r in response['results']:
+            content.append(r['content'])
+    return {"content": content}
+
+
+def should_continue(state):
+    if state["revision_number"] > state["max_revisions"]:
+        return END
+    return "reflect"
+
+
+builder = StateGraph(AgentState)
+
+builder.add_node("planner", plan_node)
+builder.add_node("generate", generation_node)
+builder.add_node("reflect", reflection_node)
+builder.add_node("research_plan", research_plan_node)
+builder.add_node("research_critique", research_critique_node)
+
+builder.set_entry_point("planner")
+
+builder.add_conditional_edges(
+    "generate",
+    should_continue,
+    {END: END, "reflect": "reflect"}
+)
+
+builder.add_edge("planner", "research_plan")
+builder.add_edge("research_plan", "generate")
+
+builder.add_edge("reflect", "research_critique")
+builder.add_edge("research_critique", "generate")
+
+
+from contextlib import ExitStack
+stack = ExitStack()
+checkpointer = stack.enter_context(SqliteSaver.from_conn_string(":memory:"))
+graph = builder.compile(checkpointer=checkpointer)
+
+#from IPython.display import Image
+#Image(graph.get_graph().draw_png())
+
+from PIL import Image as PILImage
+from io import BytesIO
+image_bytes = graph.get_graph().draw_png()
+img = PILImage.open(BytesIO(image_bytes))
+img.show()
+
+
+def create_initial_state(overrides: dict = None) -> dict:
+    # Default initial blank state
+    state = {
+        "task": "",
+        "plan": "",
+        "draft": "",
+        "critique": "",
+        "content": [],
+        "revision_number": 0,
+        "max_revisions": 3
+    }
+    if overrides:
+        state.update(overrides)
+    return state
+
+
+thread = {"configurable": {"thread_id": "1"}}
+
+initial_state = create_initial_state({
+    'task': "what is the difference between langchain and langsmith",
+    "max_revisions": 2,
+    "revision_number": 1,
+})
+
+import textwrap
+
+for s in graph.stream(initial_state, thread):
+    for k, v in s.items():
+        print(f"\n--- {k.upper()} ---")
+        if isinstance(v, dict):
+            for subkey, value in v.items():
+                if isinstance(value, str):
+                    print(f"{subkey}:\n{textwrap.fill(value, width=100)}\n")
+                elif isinstance(value, list):
+                    print(f"{subkey}:")
+                    for i, item in enumerate(value, 1):
+                        print(f"  [{i}] {textwrap.fill(str(item), width=100)}\n")
+                else:
+                    print(f"{subkey}: {value}")
+        else:
+            print(textwrap.fill(str(v), width=100))

helper.py

@@ -2,6 +2,7 @@ import warnings
 from dotenv import load_dotenv
 
 import os
+import time
 import gradio as gr
 
 from langgraph.graph import StateGraph, END
@@ -181,6 +182,7 @@ class writer_gui( ):
         self.iterations = []
         self.threads = []
         self.thread_id = -1
+        self.thread_ts_map = {}  # <----- ------>
         self.thread = {"configurable": {"thread_id": str(self.thread_id)}}
         #self.sdisps = {} #global    
         self.demo = self.create_interface()
@@ -195,6 +197,17 @@ class writer_gui( ):
                       'content': ["no content",], 'queries': "no queries", 'count':0}
             self.thread_id += 1  # new agent, new thread
             self.threads.append(self.thread_id)
+
+            # --------++++++>>
+            if self.thread_id not in self.thread_ts_map:
+                self.thread_ts_map[self.thread_id] = str(self.thread_id)  # or use a stable UUID
+
+            self.thread = {"configurable": {
+                "thread_id": str(self.thread_id),
+                "thread_ts": self.thread_ts_map[self.thread_id],
+            }}
+            # --------++++++>>
+
         else:
             config = None
 
@@ -454,3 +467,9 @@ class writer_gui( ):
             self.demo.launch(share=True, server_port=int(port), server_name="0.0.0.0")
         else:
             self.demo.launch(share=self.share)
+
+
+if __name__ == "__main__":
+    agent = ewriter()
+    gui = writer_gui(agent.graph)
+    gui.launch()

requirements.txt

@@ -9,4 +9,7 @@ langgraph-checkpoint
 langgraph-checkpoint-sqlite
 aiosqlite
 dotenv
+IPython
+pillow
+pygraphviz
 gradio