Init commit session 6

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/Multi-Agent-App.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="Python 3.13 virtualenv at ~/PycharmProjects/ai_bootcamp/AIE5-DeployPythonicRAG/.venv" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 virtualenv at ~/PycharmProjects/ai_bootcamp/AIE5-DeployPythonicRAG/.venv" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/Multi-Agent-App.iml" filepath="$PROJECT_DIR$/.idea/Multi-Agent-App.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

.python-version

@@ -0,0 +1 @@
+3.13

Dockerfile

@@ -0,0 +1,31 @@
+
+# Get a distribution that has uv already installed
+FROM ghcr.io/astral-sh/uv:python3.13-bookworm-slim
+
+# Add user - this is the user that will run the app
+# If you do not set user, the app will run as root (undesirable)
+RUN useradd -m -u 1000 user
+USER user
+
+# Set the home directory and path
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+ENV UVICORN_WS_PROTOCOL=websockets
+
+
+# Set the working directory
+WORKDIR $HOME/app
+
+# Copy the app to the container
+COPY --chown=user . $HOME/app
+
+# Install the dependencies
+# RUN uv sync --frozen
+RUN uv sync
+
+# Expose the port
+EXPOSE 7860
+
+# Run the app
+CMD ["uv", "run", "chainlit", "run", "app/app.py", "--host", "0.0.0.0", "--port", "7860"]

app/app.py

@@ -0,0 +1,130 @@
+import os
+from operator import itemgetter
+from langchain_core.runnables.base import RunnableSerializable
+import chainlit as cl
+import aiofiles
+from langchain_community.vectorstores import Qdrant
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.schema.output_parser import StrOutputParser
+from langgraph.errors import GraphRecursionError
+
+import messages as msg
+from parsers import ParsersMap
+from splitters import TextSplitter
+from models import EmbeddingLLM, MiniLLM
+from prompts import RAG_PROMPT
+from constructors import (
+    construct_research_graph,
+    construct_authoring_graph,
+    construct_super_graph,
+    construct_correctness_graph,
+)
+from utils import enter_chain
+
+
+@cl.on_chat_start
+async def init_chat():
+    files = None
+
+    # Wait for the user to upload a file
+    while files is None:
+        files = await cl.AskFileMessage(
+            content=msg.INIT_MSG,
+            accept=["text/plain", "application/pdf"],
+        ).send()
+
+    file = files[0]
+    _, ext = os.path.splitext(file.name)
+    parser = ParsersMap[ext]
+
+    async with aiofiles.open(file.path, "rb") as f:
+        file_content = await f.read()
+
+    file_text = parser.load(file_content)
+    status_msg_text = """
+    Processing...please wait
+    [1/4] Read file: {read_status}
+    [2/4] Chunk file: {split_status}
+    [3/4] Load file to DB: {load_status}
+    [4/4] Build graph: {graph_status}
+    """
+    status_msg = cl.Message(
+        status_msg_text.format(
+            read_status="🟢", split_status="🔹", load_status="🔹", graph_status="🔹"
+        )
+    )
+    await status_msg.send()
+
+    documents = TextSplitter.split_text(file_text)
+    status_msg.content = status_msg_text.format(
+        read_status="🟢", split_status="🟢", load_status="🔹", graph_status="🔹"
+    )
+    await status_msg.send()
+
+    db = Qdrant.from_texts(
+        documents,
+        EmbeddingLLM,
+        location=":memory:",
+        collection_name="multi-agent-chatbot",
+    )
+    status_msg.content = status_msg_text.format(
+        read_status="🟢", split_status="🟢", load_status="🟢", graph_status="🔹"
+    )
+    retriever = db.as_retriever()
+    await status_msg.update()
+
+    rag_prompt = ChatPromptTemplate.from_template(RAG_PROMPT)
+    chain = (
+        {
+            "context": itemgetter("question") | retriever,
+            "question": itemgetter("question"),
+        }
+        | rag_prompt
+        | MiniLLM
+        | StrOutputParser()
+    )
+    research_chain = (
+        enter_chain | construct_research_graph(research_chain=chain).compile()
+    )
+    authoring_chain = enter_chain | construct_authoring_graph().compile()
+    correctness_chain = enter_chain | construct_correctness_graph().compile()
+    super_chain = (
+        enter_chain
+        | construct_super_graph(
+            research_chain, authoring_chain, correctness_chain
+        ).compile()
+    )
+
+    cl.user_session.set("chain", super_chain)
+    status_msg.content = status_msg_text.format(
+        read_status="🟢", split_status="🟢", load_status="🟢", graph_status="🟢"
+    )
+    await status_msg.update()
+
+    await cl.Message(msg.ASK_FOR_QUERY_MSG).send()
+
+
+@cl.on_message
+async def process_chat(message: cl.Message):
+    chain: RunnableSerializable = cl.user_session.get("chain")
+    try:
+        async for s in chain.astream(message.content, {"recursion_limit": 30}):
+            if "__end__" not in s:
+                await cl.Message(s).send()
+    except GraphRecursionError:
+        await cl.Message("Max recursion depth reached").send()
+    # response = cl.Message(content="")
+    # for token in result:
+    #     await response.stream_token(token)
+    #
+    # await response.send()
+    # elements = [
+    #     cl.File(
+    #         name="hello.py",
+    #         path="./hello.py",
+    #         display="inline",
+    #     ),
+    # ]
+    # await cl.Message(
+    #     content="This message has a file element", elements=elements
+    # ).send()

app/constructors.py

@@ -0,0 +1,372 @@
+import functools
+
+from langchain.agents import AgentExecutor, create_openai_functions_agent
+from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
+from langchain.tools import Tool
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.runnables.base import RunnableSerializable
+from langchain_openai import ChatOpenAI
+from langgraph.graph import END, StateGraph
+
+from models import TurboLLM, MiniLLM
+from states import ResearchTeamState, DocWritingState, State, CorrectnessState
+from tools import (
+    TaviliTool,
+    write_document,
+    edit_document,
+    read_document,
+    create_outline,
+)
+from utils import agent_node, prelude, get_last_message, join_graph
+
+
+def construct_agent(
+    llm: ChatOpenAI, tools: list, system_prompt: str, members: list
+) -> AgentExecutor:
+    """Create a function-calling agent and add it to the graph."""
+    system_prompt += (
+        "\nWork autonomously according to your specialty, using the tools available to you."
+        " Do not ask for clarification."
+        " Your other team members (and other teams) will collaborate with you with their own specialties."
+        " You are chosen for a reason! You are one of the following team members: {team_members}."
+    )
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            (
+                "system",
+                system_prompt,
+            ),
+            MessagesPlaceholder(variable_name="messages"),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ]
+    ).partial(team_members=", ".join(members))
+    agent = create_openai_functions_agent(llm, tools, prompt)
+    executor = AgentExecutor(agent=agent, tools=tools)
+    return executor
+
+
+def construct_supervisor(
+    llm: ChatOpenAI, system_prompt: str, members: list
+) -> RunnableSerializable:
+    """An LLM-based router."""
+    options = ["FINISH"] + members
+    function_def = {
+        "name": "route",
+        "description": "Select the next role.",
+        "parameters": {
+            "title": "routeSchema",
+            "type": "object",
+            "properties": {
+                "next": {
+                    "title": "Next",
+                    "anyOf": [
+                        {"enum": options},
+                    ],
+                },
+            },
+            "required": ["next"],
+        },
+    }
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", system_prompt),
+            MessagesPlaceholder(variable_name="messages"),
+            (
+                "system",
+                "Given the conversation above, who should act next?"
+                " Or should we FINISH? Select one of: {options}",
+            ),
+        ]
+    ).partial(options=str(options), team_members=", ".join(members))
+    chain = (
+        prompt
+        | llm.bind_functions(functions=[function_def], function_call="route")
+        | JsonOutputFunctionsParser()
+    )
+    return chain
+
+
+def construct_research_graph(research_chain: RunnableSerializable) -> StateGraph:
+    retrieve_information = Tool(
+        name="RetrieveInformationTool",
+        func=lambda query: research_chain.invoke({"question": query}),
+        description="Use Retrieval Augmented Generation to retrieve information from the file provided by user.",
+    )
+    research_agent = construct_agent(
+        MiniLLM,
+        [retrieve_information],
+        "You are a research assistant who can provide specific information on the provided by user file."
+        "You must only respond with information about the paper related to the request.",
+        ["Search", "FileDataRetriever"],
+    )
+    research_node = functools.partial(
+        agent_node, agent=research_agent, name="FileDataRetriever"
+    )
+
+    search_agent = construct_agent(
+        MiniLLM,
+        [TaviliTool],
+        "You are a research assistant who can search for up-to-date info using the Tavily search engine.",
+        ["Search", "FileDataRetriever"],
+    )
+    search_node = functools.partial(agent_node, agent=search_agent, name="Search")
+
+    supervisor = construct_supervisor(
+        TurboLLM,
+        (
+            "You are a supervisor tasked with managing a conversation between the following workers:\n"
+            "{team_members}\n"
+            "Given the following user request, determine the subject to be researched and respond with the worker to act next.\n"
+            "Each worker will perform a task and respond with their results and status.\n"
+            "You should never ask your team to do anything beyond research. They are not required to write content or posts."
+            "You should only pass tasks to workers that are specifically research focused.\n"
+            "In most cases you always should use FileDataRetriever, "
+            "because it's core feature of app that will provide the most useful context.\n"
+            "When finished, respond with FINISH."
+        ),
+        ["Search", "FileDataRetriever"],
+    )
+    graph = StateGraph(ResearchTeamState)
+    graph.add_node("Search", search_node)
+    graph.add_node("FileDataRetriever", research_node)
+    graph.add_node("supervisor", supervisor)
+    graph.add_edge("Search", "supervisor")
+    graph.add_edge("FileDataRetriever", "supervisor")
+    graph.add_conditional_edges(
+        "supervisor",
+        lambda x: x["next"],
+        {
+            "Search": "Search",
+            "FileDataRetriever": "FileDataRetriever",
+            "FINISH": END,
+        },
+    )
+    graph.set_entry_point("supervisor")
+    return graph
+
+
+def construct_authoring_graph() -> StateGraph:
+    doc_writer_agent = construct_agent(
+        MiniLLM,
+        [write_document, edit_document, read_document],
+        (
+            "You are an expert writing technical LinkedIn posts.\n"
+            "Below are files currently in your directory:\n{current_files}"
+        ),
+        ["DocWriter", "NoteTaker", "DopenessEditor", "CopyEditor"],
+    )
+    context_aware_doc_writer_agent = prelude | doc_writer_agent
+    doc_writing_node = functools.partial(
+        agent_node, agent=context_aware_doc_writer_agent, name="DocWriter"
+    )
+
+    note_taking_agent = construct_agent(
+        MiniLLM,
+        [create_outline, read_document],
+        (
+            "You are an expert senior researcher tasked with writing a LinkedIn post outline and"
+            " taking notes to craft a LinkedIn post.\n{current_files}"
+        ),
+        ["DocWriter", "NoteTaker", "DopenessEditor", "CopyEditor"],
+    )
+    context_aware_note_taking_agent = prelude | note_taking_agent
+    note_taking_node = functools.partial(
+        agent_node, agent=context_aware_note_taking_agent, name="NoteTaker"
+    )
+
+    copy_editor_agent = construct_agent(
+        MiniLLM,
+        [write_document, edit_document, read_document],
+        (
+            "You are an expert copy editor who focuses on fixing grammar, spelling, and tone issues\n"
+            "Below are files currently in your directory:\n{current_files}"
+        ),
+        ["DocWriter", "NoteTaker", "DopenessEditor", "CopyEditor"],
+    )
+    context_aware_copy_editor_agent = prelude | copy_editor_agent
+    copy_editing_node = functools.partial(
+        agent_node, agent=context_aware_copy_editor_agent, name="CopyEditor"
+    )
+
+    dopeness_editor_agent = construct_agent(
+        MiniLLM,
+        [write_document, edit_document, read_document],
+        (
+            "You are an expert in dopeness, litness, coolness, etc - you edit the document to make sure it's dope. Make sure to use a number of emojis."
+            "Below are files currently in your directory:\n{current_files}"
+        ),
+        ["DocWriter", "NoteTaker", "DopenessEditor", "CopyEditor"],
+    )
+    context_aware_dopeness_editor_agent = prelude | dopeness_editor_agent
+    dopeness_node = functools.partial(
+        agent_node, agent=context_aware_dopeness_editor_agent, name="DopenessEditor"
+    )
+
+    supervisor = construct_supervisor(
+        TurboLLM,
+        (
+            "You are a supervisor tasked with managing a conversation between the"
+            " following workers: {team_members}. You should always verify the technical"
+            " contents after any edits are made. "
+            "Given the following user request,"
+            " respond with the worker to act next. Each worker will perform a"
+            " task and respond with their results and status. When each team is finished,"
+            " you must respond with FINISH."
+        ),
+        ["DocWriter", "NoteTaker", "DopenessEditor", "CopyEditor"],
+    )
+
+    graph = StateGraph(DocWritingState)
+    graph.add_node("DocWriter", doc_writing_node)
+    graph.add_node("NoteTaker", note_taking_node)
+    graph.add_node("CopyEditor", copy_editing_node)
+    graph.add_node("DopenessEditor", dopeness_node)
+    graph.add_node("supervisor", supervisor)
+
+    graph.add_edge("DocWriter", "supervisor")
+    graph.add_edge("NoteTaker", "supervisor")
+    graph.add_edge("CopyEditor", "supervisor")
+    graph.add_edge("DopenessEditor", "supervisor")
+
+    graph.add_conditional_edges(
+        "supervisor",
+        lambda x: x["next"],
+        {
+            "DocWriter": "DocWriter",
+            "NoteTaker": "NoteTaker",
+            "CopyEditor": "CopyEditor",
+            "DopenessEditor": "DopenessEditor",
+            "FINISH": END,
+        },
+    )
+
+    graph.set_entry_point("supervisor")
+    return graph
+
+
+def construct_correctness_graph() -> StateGraph:
+    style_agent = prelude | construct_agent(
+        MiniLLM,
+        [edit_document, read_document],
+        (
+            "You are an expert in analyzing LinkedIn posts.\n"
+            "Please verify the produced paper fits the theme and style of selected social media platform.\n"
+            "Make edits to the file to make it perfect for posting on social media.\n"
+            "Below are files currently in your directory:\n"
+            "{current_files}\n"
+        ),
+        ["StyleChecker", "EthicChecker", "FactChecker"],
+    )
+    style_node = functools.partial(agent_node, agent=style_agent, name="StyleChecker")
+    ethic_agent = prelude | construct_agent(
+        MiniLLM,
+        [edit_document, read_document],
+        (
+            "You are an expert in analyzing LinkedIn posts.\n"
+            "Please verify the produced paper does not violate the platform rules, "
+            "does not offend anyone and will not cause moral damage to anyone\n"
+            "Make edits to the file to make it perfect for posting on social media.\n"
+            "Below are files currently in your directory:\n"
+            "{current_files}\n"
+        ),
+        ["StyleChecker", "EthicChecker", "FactChecker"],
+    )
+    ethic_node = functools.partial(agent_node, agent=ethic_agent, name="EthicChecker")
+    fact_agent = prelude | construct_agent(
+        MiniLLM,
+        [edit_document, read_document, TaviliTool],
+        (
+            "You are an expert in analyzing LinkedIn posts.\n"
+            "Please verify the produced paper corresponds to reality, "
+            "there is no false or distorted information, "
+            "that there is no obvious slander.\n"
+            "For fact-checking, use the Tavili search engine, "
+            "to which you have access in the form of a tool.\n"
+            "Make edits to the file to make it perfect for posting on social media.\n"
+            "Below are files currently in your directory:\n"
+            "{current_files}\n"
+        ),
+        ["StyleChecker", "EthicChecker", "FactChecker"],
+    )
+    fact_node = functools.partial(agent_node, agent=fact_agent, name="FactChecker")
+    supervisor = construct_supervisor(
+        TurboLLM,
+        (
+            "You are a supervisor tasked with managing a conversation between the following workers: {team_members}.\n"
+            "You should always verify the technical contents after any edits are made.\n"
+            "Try to use the maximum number of workers, because each of them significantly affects the quality of "
+            "the generated response and the rule 'The More, The Better' works here, "
+            "so if you are not sure which workers to choose, choose all of them\n"
+            "Given the following user request, respond with the worker to act next.\n"
+            "Each worker will perform a task and respond with their results and status.\n"
+            "When each team is finished, you must respond with FINISH.\n"
+        ),
+        ["StyleChecker", "EthicChecker", "FactChecker"],
+    )
+    graph = StateGraph(CorrectnessState)
+    graph.add_node("StyleChecker", style_node)
+    graph.add_node("EthicChecker", ethic_node)
+    graph.add_node("FactChecker", fact_node)
+    graph.add_node("supervisor", supervisor)
+
+    graph.add_edge("StyleChecker", "supervisor")
+    graph.add_edge("EthicChecker", "supervisor")
+    graph.add_edge("FactChecker", "supervisor")
+
+    graph.add_conditional_edges(
+        "supervisor",
+        lambda x: x["next"],
+        {
+            "StyleChecker": "StyleChecker",
+            "EthicChecker": "EthicChecker",
+            "FactChecker": "FactChecker",
+            "FINISH": END,
+        },
+    )
+
+    graph.set_entry_point("supervisor")
+    return graph
+
+
+def construct_super_graph(
+    research_chain: RunnableSerializable,
+    authoring_chain: RunnableSerializable,
+    correctness_chain: RunnableSerializable,
+) -> StateGraph:
+    supervisor_node = construct_supervisor(
+        TurboLLM,
+        "You are a supervisor tasked with managing a conversation between the"
+        " following teams: {team_members}. Given the following user request,"
+        " respond with the worker to act next. Each worker will perform a"
+        " task and respond with their results and status. When all workers are finished,"
+        " you must respond with FINISH.",
+        ["Research team", "LinkedIn team", "Correctness team"],
+    )
+    super_graph = StateGraph(State)
+    super_graph.add_node(
+        "Research team", get_last_message | research_chain | join_graph
+    )
+    super_graph.add_node(
+        "LinkedIn team", get_last_message | authoring_chain | join_graph
+    )
+    super_graph.add_node(
+        "Correctness team", get_last_message | correctness_chain | join_graph
+    )
+    super_graph.add_node("supervisor", supervisor_node)
+
+    super_graph.add_edge("Research team", "supervisor")
+    super_graph.add_edge("LinkedIn team", "supervisor")
+    super_graph.add_edge("Correctness team", "supervisor")
+
+    super_graph.add_conditional_edges(
+        "supervisor",
+        lambda x: x["next"],
+        {
+            "LinkedIn team": "LinkedIn team",
+            "Research team": "Research team",
+            "Correctness team": "Correctness team",
+            "FINISH": END,
+        },
+    )
+    super_graph.set_entry_point("supervisor")
+    return super_graph

app/messages.py

@@ -0,0 +1,12 @@
+INIT_MSG = """
+Hello!
+Please upload the file and I will make you a cool template for a social media post based on the file's contents!
+It may take some time to process the file, so please be patient.
+"""
+
+ASK_FOR_QUERY_MSG = """
+Cool, now provide me any topic from this file and I'll return file with social media post.
+You can also specify exact social media name and I'll optimize the post.
+Example: 
+`The topic is: "Why AI will conquer the world" and social media is Twitter`
+"""

app/models.py

@@ -0,0 +1,6 @@
+from langchain_openai import ChatOpenAI
+from langchain_openai.embeddings import OpenAIEmbeddings
+
+EmbeddingLLM = OpenAIEmbeddings(model="text-embedding-3-small")
+MiniLLM = ChatOpenAI(model="gpt-4o-mini")
+TurboLLM = ChatOpenAI(model="gpt-4-turbo")

app/parsers.py

@@ -0,0 +1,29 @@
+from abc import abstractmethod, ABC
+from io import BytesIO
+
+import PyPDF2
+
+
+class BaseParser(ABC):
+    @abstractmethod
+    def load(self, data: bytes) -> str:
+        ...
+
+
+class TxtParser(BaseParser):
+    def load(self, data: bytes) -> str:
+        return data.decode("utf-8", errors="ignore")
+
+
+class PdfParser(BaseParser):
+    def load(self, data: bytes) -> str:
+        pdf_stream = BytesIO(data)
+        pdf_reader = PyPDF2.PdfReader(pdf_stream)
+        extracted_text = ""
+        for page_num in range(len(pdf_reader.pages)):
+            page = pdf_reader.pages[page_num]
+            extracted_text += page.extract_text()
+        return extracted_text
+
+
+ParsersMap: dict[str, BaseParser] = {".txt": TxtParser(), ".pdf": PdfParser()}

app/prompts.py

@@ -0,0 +1,11 @@
+RAG_PROMPT = """
+CONTEXT:
+{context}
+
+QUERY:
+{question}
+
+You are a helpful assistant that creates social media posts based on the provided context (RAG). 
+Use the available context to generate response.
+If there is no context please say: "Nothing found in source file".
+"""

app/splitters.py

@@ -0,0 +1,9 @@
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from utils import tiktoken_len
+
+
+TextSplitter = RecursiveCharacterTextSplitter(
+    chunk_size=300,
+    chunk_overlap=0,
+    length_function=tiktoken_len,
+)

app/states.py

@@ -0,0 +1,28 @@
+import operator
+from typing import TypedDict
+
+from langchain_core.messages import BaseMessage
+from typing import Annotated, List
+
+
+class ResearchTeamState(TypedDict):
+    messages: Annotated[List[BaseMessage], operator.add]
+    team_members: List[str]
+    next: str
+
+
+class DocWritingState(TypedDict):
+    messages: Annotated[List[BaseMessage], operator.add]
+    team_members: str
+    next: str
+    current_files: str
+
+
+class CorrectnessState(TypedDict):
+    messages: Annotated[List[BaseMessage], operator.add]
+    next: str
+
+
+class State(TypedDict):
+    messages: Annotated[List[BaseMessage], operator.add]
+    next: str

app/tools.py

@@ -0,0 +1,73 @@
+from typing import Annotated, List, Dict, Optional
+
+from langchain.tools import tool
+from langchain_community.tools.tavily_search import TavilySearchResults
+
+from utils import WORKING_DIRECTORY
+
+
+TaviliTool = TavilySearchResults(max_results=3)
+
+
+@tool
+def create_outline(
+    points: Annotated[List[str], "List of main points or sections."],
+    file_name: Annotated[str, "File path to save the outline."],
+) -> Annotated[str, "Path of the saved outline file."]:
+    """Create and save an outline."""
+    with (WORKING_DIRECTORY / file_name).open("w") as file:
+        for i, point in enumerate(points):
+            file.write(f"{i + 1}. {point}\n")
+    return f"Outline saved to {file_name}"
+
+
+@tool
+def read_document(
+    file_name: Annotated[str, "File path to save the document."],
+    start: Annotated[Optional[int], "The start line. Default is 0"] = None,
+    end: Annotated[Optional[int], "The end line. Default is None"] = None,
+) -> str:
+    """Read the specified document."""
+    with (WORKING_DIRECTORY / file_name).open("r") as file:
+        lines = file.readlines()
+    if start is not None:
+        start = 0
+    return "\n".join(lines[start:end])
+
+
+@tool(return_direct=True)
+def write_document(
+    content: Annotated[str, "Text content to be written into the document."],
+    file_name: Annotated[str, "File path to save the document."],
+) -> Annotated[str, "Path of the saved document file."]:
+    """Create and save a text document."""
+    with (WORKING_DIRECTORY / file_name).open("w") as file:
+        file.write(content)
+    return f"Document saved to {file_name}"
+
+
+@tool
+def edit_document(
+    file_name: Annotated[str, "Path of the document to be edited."],
+    inserts: Annotated[
+        Dict[int, str],
+        "Dictionary where key is the line number (1-indexed) and value is the text to be inserted at that line.",
+    ] = None,
+) -> Annotated[str, "Path of the edited document file."]:
+    """Edit a document by inserting text at specific line numbers."""
+    inserts = {} if inserts is None else inserts
+    with (WORKING_DIRECTORY / file_name).open("r") as file:
+        lines = file.readlines()
+
+    sorted_inserts = sorted(inserts.items())
+
+    for line_number, text in sorted_inserts:
+        if 1 <= line_number <= len(lines) + 1:
+            lines.insert(line_number - 1, text + "\n")
+        else:
+            return f"Error: Line number {line_number} is out of range."
+
+    with (WORKING_DIRECTORY / file_name).open("w") as file:
+        file.writelines(lines)
+
+    return f"Document edited and saved to {file_name}"

app/utils.py

@@ -0,0 +1,65 @@
+import os
+import uuid
+from pathlib import Path
+import tiktoken
+from langchain_core.messages import HumanMessage
+
+from states import State
+
+os.makedirs("./data", exist_ok=True)
+
+
+def tiktoken_len(text):
+    tokens = tiktoken.encoding_for_model("gpt-4o-mini").encode(
+        text,
+    )
+    return len(tokens)
+
+
+def agent_node(state, agent, name):
+    result = agent.invoke(state)
+    return {"messages": [HumanMessage(content=result["output"], name=name)]}
+
+
+def enter_chain(message: str) -> dict:
+    results = {
+        "messages": [HumanMessage(content=message)],
+    }
+    return results
+
+
+def get_last_message(state: State) -> str:
+    return state["messages"][-1].content
+
+
+def join_graph(response: dict):
+    return {"messages": [response["messages"][-1]]}
+
+
+def create_random_subdirectory():
+    random_id = str(uuid.uuid4())[:8]  # Use first 8 characters of a UUID
+    subdirectory_path = os.path.join("./data", random_id)
+    os.makedirs(subdirectory_path, exist_ok=True)
+    return subdirectory_path
+
+
+def prelude(state):
+    written_files = []
+    if not WORKING_DIRECTORY.exists():
+        WORKING_DIRECTORY.mkdir()
+    try:
+        written_files = [
+            f.relative_to(WORKING_DIRECTORY) for f in WORKING_DIRECTORY.rglob("*")
+        ]
+    except Exception:
+        pass
+    if not written_files:
+        return {**state, "current_files": "No files written."}
+    return {
+        **state,
+        "current_files": "\nBelow are files your team has written to the directory:\n"
+        + "\n".join([f" - {f}" for f in written_files]),
+    }
+
+
+WORKING_DIRECTORY = Path(create_random_subdirectory())

chainlit.md

@@ -0,0 +1,14 @@
+# Welcome to Chainlit! 🚀🤖
+
+Hi there, Developer! 👋 We're excited to have you on board. Chainlit is a powerful tool designed to help you prototype, debug and share applications built on top of LLMs.
+
+## Useful Links 🔗
+
+- **Documentation:** Get started with our comprehensive [Chainlit Documentation](https://docs.chainlit.io) 📚
+- **Discord Community:** Join our friendly [Chainlit Discord](https://discord.gg/k73SQ3FyUh) to ask questions, share your projects, and connect with other developers! 💬
+
+We can't wait to see what you create with Chainlit! Happy coding! 💻😊
+
+## Welcome screen
+
+To modify the welcome screen, edit the `chainlit.md` file at the root of your project. If you do not want a welcome screen, just leave this file empty.

data/4fd7e547/Mu_Shu_Pork_Recipe.md

@@ -0,0 +1,42 @@
+🌟 Exciting Culinary Experience: Mu Shu Pork Recipe! 🌟
+
+Have you ever tried making Mu Shu Pork at home? If not, now is the perfect time to roll up your sleeves and dive into this delicious dish! 🤤 Here’s a simple yet mouth-watering recipe to bring a taste of Chinese cuisine to your kitchen.
+
+**Ingredients:**
+- 1/2 lb pork tenderloin, cut into 1/4-inch strips
+
+**Marinade:**
+- 2 tsps soy sauce  
+- 1/2 tsp cornstarch  
+- 1/8 tsp salt  
+- 1/2 tsp dry sherry  
+- 1/4 tsp sugar  
+
+**Cooking Sauce:**
+- 2 tsps soy sauce  
+- 2 tsps dry sherry  
+- 1 tsp sesame oil  
+- 1/2 tsp sugar  
+
+**Other Essentials:**
+- 10 6-inch flour tortillas  
+- 2 1/2 tsps cooking oil  
+- 2 eggs, beaten with 1/4 tsp salt  
+- 1 1/2 oz vermicelli, soaked and cut into 2-inch pieces  
+- 1 large tree ear mushroom, soaked and thinly sliced  
+- 4 medium Chinese dried mushrooms, soaked and thinly sliced  
+- 3 whole green onions, shredded  
+- 1/2 cup red bell pepper, shredded  
+- 1/2 cup bamboo shoots, cut into matchstick pieces  
+- Hoisin sauce for serving  
+
+**Instructions:**
+1. Combine marinade ingredients with the pork and let it marinate.
+2. Wrap tortillas in foil and warm in a 350°F oven for 10 minutes.
+3. Heat a skillet with oil, cook the beaten eggs into a thin pancake, remove, and cut into strips.
+
+Enjoy your homemade Mu Shu Pork! ✅🍽️✨ 
+
+Let me know how yours turns out! #Cooking #Recipe #MuShuPork #Foodie
+
+Feel free to share your thoughts and any variations you try! 🍜🥢

data/4fd7e547/Mu_Shu_Pork_Recipe_Outline.md

@@ -0,0 +1,8 @@
+1. Introduction to Mu Shu Pork
+2. Ingredients List
+3. Marinade Components
+4. Cooking Sauce Ingredients
+5. Essential Cooking Items
+6. Step-by-Step Instructions
+7. Serving Suggestions
+8. Call-to-Action

pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "06-multi-agent-with-langgraph"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "aiofiles>=23.2.1",
+    "arxiv>=2.1.3",
+    "chainlit>=2.1.1",
+    "jupyter>=1.1.1",
+    "langchain>=0.3.17",
+    "langchain-community>=0.3.16",
+    "langchain-core>=0.3.33",
+    "langchain-openai>=0.3.3",
+    "langgraph>=0.2.69",
+    "pymupdf>=1.25.2",
+    "pypdf2>=3.0.1",
+    "qdrant-client>=1.13.2",
+    "tiktoken>=0.8.0",
+]