Create multiagent.py

multiagent.py

@@ -0,0 +1,336 @@
+#Change to requirements caller
+import sys
+import subprocess
+
+def run_pip_install():
+    packages = [
+        "langgraph",
+        "langchain",
+        "langchain_openai",
+        "langchain_experimental",
+        "qdrant-client",
+        "pymupdf",
+        "tiktoken",
+        "huggingface_hub",
+        "openai",
+        "tavily-python"
+    ]
+    
+    package_string = " ".join(packages)
+    
+    try:
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "-qU"] + packages)
+        print("All required packages have been installed successfully.")
+    except subprocess.CalledProcessError:
+        print(f"Failed to install packages. Please run the following command manually:")
+        print(f"%pip install -qU {package_string}")
+        sys.exit(1)
+
+# Run pip install
+run_pip_install()
+
+import os
+import functools
+import operator
+from typing import Annotated, List, Tuple, Union, Dict, Optional
+from typing_extensions import TypedDict
+import uuid
+from pathlib import Path
+
+from langchain_core.tools import tool
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_openai import ChatOpenAI
+from langchain.agents import AgentExecutor, create_openai_functions_agent
+from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.vectorstores import Qdrant
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_openai.embeddings import OpenAIEmbeddings
+from langgraph.graph import END, StateGraph
+from huggingface_hub import hf_hub_download
+
+# Environment setup
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+TAVILY_API_KEY = os.environ.get("TAVILY_API_KEY")
+
+if not OPENAI_API_KEY:
+    raise ValueError("OPENAI_API_KEY not found in environment variables")
+if not TAVILY_API_KEY:
+    raise ValueError("TAVILY_API_KEY not found in environment variables")
+
+os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+os.environ["TAVILY_API_KEY"] = TAVILY_API_KEY
+
+# CHANGE TO HF DIRECTORY
+WORKING_DIRECTORY = Path("/tmp/content/data")
+WORKING_DIRECTORY.mkdir(parents=True, exist_ok=True)
+
+# Utility functions
+def create_random_subdirectory():
+    random_id = str(uuid.uuid4())[:8]
+    subdirectory_path = WORKING_DIRECTORY / random_id
+    subdirectory_path.mkdir(exist_ok=True)
+    return subdirectory_path
+
+def get_current_files():
+    try:
+        files = [f.relative_to(WORKING_DIRECTORY) for f in WORKING_DIRECTORY.rglob("*") if f.is_file()]
+        return "\n".join(str(f) for f in files) if files else "No files written."
+    except Exception:
+        return "Unable to retrieve current files."
+
+# Document loading change to upload in HF 
+def fetch_hbr_article():
+    pdf_path = hf_hub_download(repo_id="your-username/your-repo-name", filename="murthy-loneliness.pdf")
+    return PyMuPDFLoader(pdf_path).load()
+
+# Document processing
+def tiktoken_len(text):
+    tokens = tiktoken.encoding_for_model("gpt-4o-mini").encode(text)
+    return len(tokens)
+
+text_splitter = RecursiveCharacterTextSplitter(
+    chunk_size=300,
+    chunk_overlap=0,
+    length_function=tiktoken_len,
+)
+
+docs = fetch_hbr_article()
+split_chunks = text_splitter.split_documents(docs)
+
+# Embedding and vector store setup
+embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
+qdrant_vectorstore = Qdrant.from_documents(
+    split_chunks,
+    embedding_model,
+    location=":memory:",
+    collection_name="extending_context_window_llama_3",
+)
+qdrant_retriever = qdrant_vectorstore.as_retriever()
+
+# RAG setup
+RAG_PROMPT = """
+CONTEXT:
+{context}
+
+QUERY:
+{question}
+
+You are a helpful assistant. Use the available context to answer the question. If you can't answer the question, say you don't know.
+"""
+rag_prompt = ChatPromptTemplate.from_template(RAG_PROMPT)
+openai_chat_model = ChatOpenAI(model="gpt-4o-mini")
+
+rag_chain = (
+    {"context": itemgetter("question") | qdrant_retriever, "question": itemgetter("question")}
+    | rag_prompt | openai_chat_model | StrOutputParser()
+)
+
+# Tool definitions
+@tool
+def create_outline(points: List[str], file_name: str) -> str:
+    """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: str, start: Optional[int] = None, end: Optional[int] = 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
+def write_document(content: str, file_name: str) -> str:
+    """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: str, inserts: Dict[int, str] = {}) -> str:
+    """Edit a document by inserting text at specific line numbers."""
+    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}"
+
+@tool
+def retrieve_information(query: str):
+    """Use Retrieval Augmented Generation to retrieve information about the 'murthy-loneliness' paper."""
+    return rag_chain.invoke({"question": query})
+
+# Agent creation helpers
+def create_team_agent(llm, tools, system_prompt, agent_name, team_members):
+    return create_agent(
+        llm,
+        tools,
+        f"{system_prompt}\nBelow are files currently in your directory:\n{{current_files}}",
+        team_members
+    )
+
+def create_agent_node(agent, name):
+    return functools.partial(agent_node, agent=agent, name=name)
+
+def add_agent_to_graph(graph, agent_name, agent_node):
+    graph.add_node(agent_name, agent_node)
+    graph.add_edge(agent_name, "supervisor")
+
+def create_team_supervisor(llm, team_description, team_members):
+    return create_team_supervisor(
+        llm,
+        f"You are a supervisor tasked with managing a conversation between the"
+        f" following workers: {', '.join(team_members)}. {team_description}"
+        f" When all workers are finished, you must respond with FINISH.",
+        team_members
+    )
+
+def create_team_chain(graph, team_members):
+    return (
+        functools.partial(enter_chain, members=team_members)
+        | graph.compile()
+    )
+
+# LLM setup
+llm = ChatOpenAI(model="gpt-4-turbo")
+
+# Agent creation
+tavily_tool = TavilySearchResults(max_results=5)
+
+search_agent = create_team_agent(
+    llm,
+    [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(
+    llm,
+    [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(
+    llm,
+    [write_document, edit_document, read_document],
+    "You are an expert writing technical social media posts.",
+    "DocWriter",
+    ["DocWriter", "NoteTaker", "CopyEditor", "VoiceEditor"]
+)
+
+note_taking_agent = create_team_agent(
+    llm,
+    [create_outline, 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(
+    llm,
+    [write_document, edit_document, 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(
+    llm,
+    [write_document, edit_document, 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"]
+)
+
+# Node creation
+search_node = create_agent_node(search_agent, "Search")
+research_node = create_agent_node(research_agent, "PaperInformationRetriever")
+doc_writing_node = create_agent_node(doc_writer_agent, "DocWriter")
+note_taking_node = create_agent_node(note_taking_agent, "NoteTaker")
+copy_editing_node = create_agent_node(copy_editor_agent, "CopyEditor")
+voice_node = create_agent_node(voice_editor_agent, "VoiceEditor")
+
+# Graph creation
+research_graph = StateGraph(ResearchTeamState)
+add_agent_to_graph(research_graph, "Search", search_node)
+add_agent_to_graph(research_graph, "PaperInformationRetriever", research_node)
+
+authoring_graph = StateGraph(DocWritingState)
+add_agent_to_graph(authoring_graph, "DocWriter", doc_writing_node)
+add_agent_to_graph(authoring_graph, "NoteTaker", note_taking_node)
+add_agent_to_graph(authoring_graph, "CopyEditor", copy_editing_node)
+add_agent_to_graph(authoring_graph, "VoiceEditor", voice_node)
+
+# Supervisor creation
+research_supervisor = create_team_supervisor(
+    llm,
+    "Given the following user request, determine the subject to be researched and respond with the worker to act next.",
+    ["Search", "PaperInformationRetriever"]
+)
+
+doc_writing_supervisor = create_team_supervisor(
+    llm,
+    "Given the following user request, determine which worker should act next. Each worker will perform a task and respond with their results and status.",
+    ["DocWriter", "NoteTaker", "CopyEditor", "VoiceEditor"]
+)
+
+# Graph compilation
+research_graph.add_node("supervisor", research_supervisor)
+research_graph.set_entry_point("supervisor")
+research_chain = create_team_chain(research_graph, research_graph.nodes)
+
+authoring_graph.add_node("supervisor", doc_writing_supervisor)
+authoring_graph.set_entry_point("supervisor")
+authoring_chain = create_team_chain(authoring_graph, authoring_graph.nodes)
+
+# Meta-supervisor setup
+super_graph = StateGraph(State)
+super_graph.add_node("Research team", get_last_message | research_chain | join_graph)
+super_graph.add_node("SocialMedia team", get_last_message | authoring_chain | join_graph)
+super_graph.add_node("supervisor", supervisor_node)
+
+super_graph.add_edge("Research team", "supervisor")
+super_graph.add_edge("SocialMedia team", "supervisor")
+super_graph.add_conditional_edges(
+    "supervisor",
+    lambda x: x["next"],
+    {
+        "SocialMedia team": "SocialMedia team",
+        "Research team": "Research team",
+        "FINISH": END,
+    },
+)
+super_graph.set_entry_point("supervisor")
+super_graph = super_graph.compile()
+
+# Example usage
+user_input = input("Enter your request for the social media post: ")
+
+for s in super_graph.stream(
+    {
+        "messages": [
+            HumanMessage(content=user_input)
+        ],
+    },
+    {"recursion_limit": 50},
+):
+    if "__end__" not in s:
+        print(s)
+        print("---")