Delete app.py

app.py

@@ -1,538 +0,0 @@
-import os
-import streamlit as st
-from pathlib import Path
-from tempfile import TemporaryDirectory
-from langchain_core.messages import BaseMessage, HumanMessage
-from typing import Annotated, List, Optional, Dict
-from typing_extensions import TypedDict
-from langchain_community.document_loaders import WebBaseLoader
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_core.tools import tool
-from langchain.agents import AgentExecutor, create_openai_functions_agent
-from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
-from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain_openai import ChatOpenAI
-from langgraph.graph import END, StateGraph, START
-import functools
-import operator
-import logging
-import time
-from tenacity import retry, stop_after_attempt, wait_exponential
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Streamlit UI
-st.set_page_config(page_title="MARS: Multi-Agent Report Synthesizer", layout="wide")
-
-# Custom CSS for styling
-st.markdown("""
-    <style>
-        body {
-            background-color: #f5f5f5;
-            color: #333333;
-            font-family: 'Comic Sans MS', 'Comic Sans', cursive;
-        }
-        .report-container {
-            border-radius: 10px;
-            background-color: #ffcccb;
-            padding: 20px;
-        }
-        .sidebar .sidebar-content {
-            background-color: #333333;
-            color: #ffffff;
-        }
-        .stButton button {
-            background-color: #ff6347;
-            color: #ffffff;
-            border-radius: 5px;
-            font-size: 18px;
-            padding: 10px 20px;
-            font-weight: bold;
-        }
-        .stTextInput input {
-            border-radius: 5px;
-            border: 2px solid #ff6347;
-            font-size: 16px;
-            padding: 10px;
-            width: 100%;
-        }
-        .stTextInput label {
-            font-size: 18px;
-            font-weight: bold;
-            color: #333333;
-        }
-        .stSelectbox label, .stDownloadButton label {
-            font-size: 18px;
-            font-weight: bold;
-            color: #333333;
-        }
-        .stSelectbox div, .stDownloadButton div {
-            background-color: #ffcccb;
-            color: #333333;
-            border-radius: 5px;
-            padding: 10px;
-            font-size: 16px;
-        }
-    </style>
-""", unsafe_allow_html=True)
-
-st.title("🚀 MARS: Multi-agent Report Synthesizer 🤖")
-
-# Sidebar for API key inputs
-st.sidebar.title("API Keys")
-openai_api_key = st.sidebar.text_input("OpenAI API Key", type="password")
-tavily_api_key = st.sidebar.text_input("Tavily API Key", type="password")
-
-# Only set environment variables if API keys are provided
-if openai_api_key:
-    os.environ["OPENAI_API_KEY"] = openai_api_key
-if tavily_api_key:
-    os.environ["TAVILY_API_KEY"] = tavily_api_key
-
-# Use environment variables as fallback
-openai_api_key = openai_api_key or os.getenv("OPENAI_API_KEY")
-tavily_api_key = tavily_api_key or os.getenv("TAVILY_API_KEY")
-
-st.sidebar.title("📋 Instructions")
-st.sidebar.write("""
-1. Enter your OpenAI and Tavily API keys in the fields above.
-2. Enter your query in the input box.
-3. Marvin AI will assign tasks to different teams.
-4. You can see the progress and download the final report.
-5. Use the buttons to list and download output files.
-""")
-
-# Set environment variables
-os.environ["LANGCHAIN_TRACING_V2"] = "true"
-
-# Initialize temporary directory
-if 'working_directory' not in st.session_state:
-    _TEMP_DIRECTORY = TemporaryDirectory()
-    st.session_state.working_directory = Path(_TEMP_DIRECTORY.name)
-
-WORKING_DIRECTORY = st.session_state.working_directory
-
-# Define tools
-@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
-def tavily_search_with_retry(*args, **kwargs):
-    return TavilySearchResults(*args, **kwargs)
-
-tavily_tool = tavily_search_with_retry(max_results=5, api_key=tavily_api_key)
-
-@tool
-def scrape_webpages(urls: List[str]) -> str:
-    """Use requests and bs4 to scrape the provided web pages for detailed information."""
-    try:
-        loader = WebBaseLoader(urls)
-        docs = loader.load()
-        return "\n\n".join(
-            [
-                f'\n{doc.page_content}\n'
-                for doc in docs
-            ]
-        )
-    except Exception as e:
-        logger.error(f"Error in scrape_webpages: {str(e)}")
-        return f"Error occurred while scraping webpages: {str(e)}"
-
-@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."""
-    try:
-        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}"
-    except Exception as e:
-        logger.error(f"Error in create_outline: {str(e)}")
-        return f"Error occurred while creating outline: {str(e)}"
-
-@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."""
-    try:
-        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])
-    except Exception as e:
-        logger.error(f"Error in read_document: {str(e)}")
-        return f"Error occurred while reading document: {str(e)}"
-
-@tool
-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."""
-    try:
-        with (WORKING_DIRECTORY / file_name).open("w") as file:
-            file.write(content)
-        return f"Document saved to {file_name}"
-    except Exception as e:
-        logger.error(f"Error in write_document: {str(e)}")
-        return f"Error occurred while writing document: {str(e)}"
-
-@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.",
-    ],
-) -> Annotated[str, "Path of the edited document file."]:
-    """Edit a document by inserting text at specific line numbers."""
-    try:
-        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}"
-    except Exception as e:
-        logger.error(f"Error in edit_document: {str(e)}")
-        return f"Error occurred while editing document: {str(e)}"
-
-# Define the agents and their tools
-llm = ChatOpenAI(model="gpt-3.5-turbo-0125", api_key=openai_api_key)
-
-def create_agent(llm: ChatOpenAI, tools: list, system_prompt: str) -> str:
-    """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"),
-        ]
-    )
-    agent = create_openai_functions_agent(llm, tools, prompt)
-    executor = AgentExecutor(agent=agent, tools=tools)
-    return executor
-
-def agent_node(state, agent, name):
-    try:
-        logger.info(f"Starting {name} agent")
-        result = agent.invoke(state)
-        logger.info(f"{name} agent completed with result: {result}")
-        return {"messages": [HumanMessage(content=result["output"], name=name)]}
-    except Exception as e:
-        logger.error(f"Error in {name} agent: {str(e)}")
-        return {"messages": [HumanMessage(content=f"Error occurred in {name} agent: {str(e)}", name=name)]}
-
-def create_team_supervisor(llm: ChatOpenAI, system_prompt, members) -> str:
-    """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"],
-        },
-    }
-    system_prompt += "\nEnsure that you direct the workflow to completion. If no progress is being made, or if the task seems complete, choose FINISH."
-    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))
-    return (
-        prompt
-        | llm.bind_functions(functions=[function_def], function_call="route")
-        | JsonOutputFunctionsParser()
-    )
-
-# ResearchTeam graph state
-class ResearchTeamState(TypedDict):
-    messages: Annotated[List[BaseMessage], operator.add]
-    team_members: List[str]
-    next: str
-
-search_agent = create_agent(
-    llm,
-    [tavily_tool],
-    "You are a research assistant who can search for up-to-date info using the tavily search engine.",
-)
-search_node = functools.partial(agent_node, agent=search_agent, name="Search")
-
-research_agent = create_agent(
-    llm,
-    [scrape_webpages],
-    "You are a research assistant who can scrape specified urls for more detailed information using the scrape_webpages function.",
-)
-research_node = functools.partial(agent_node, agent=research_agent, name="WebScraper")
-
-supervisor_agent = create_team_supervisor(
-    llm,
-    "You are a supervisor tasked with managing a conversation between the"
-    " following workers: Search, WebScraper. 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 finished,"
-    " respond with FINISH.",
-    ["Search", "WebScraper"],
-)
-
-research_graph = StateGraph(ResearchTeamState)
-research_graph.add_node("Search", search_node)
-research_graph.add_node("WebScraper", research_node)
-research_graph.add_node("supervisor", supervisor_agent)
-
-# Define the control flow
-research_graph.add_edge("Search", "supervisor")
-research_graph.add_edge("WebScraper", "supervisor")
-research_graph.add_conditional_edges(
-    "supervisor",
-    lambda x: x["next"],
-    {"Search": "Search", "WebScraper": "WebScraper", "FINISH": END},
-)
-
-research_graph.add_edge(START, "supervisor")
-chain = research_graph.compile()
-
-def enter_chain(message: str):
-    results = {
-        "messages": [HumanMessage(content=message)],
-    }
-    return results
-
-research_chain = enter_chain | chain
-
-# Document writing team graph state
-class DocWritingState(TypedDict):
-    messages: Annotated[List[BaseMessage], operator.add]
-    team_members: str
-    next: str
-    current_files: str
-
-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]),
-    }
-
-doc_writer_agent = create_agent(
-    llm,
-    [write_document, edit_document, read_document],
-    "You are an expert writing a research document.\n"
-    "Below are files currently in your directory:\n{current_files}",
-)
-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 = create_agent(
-    llm,
-    [create_outline, read_document],
-    "You are an expert senior researcher tasked with writing a paper outline and"
-    " taking notes to craft a perfect paper.{current_files}",
-)
-context_aware_note_taking_agent = prelude | note_taking_agent
-note_taking_node = functools.partial(
-    agent_node, agent=context_aware_note_taking_agent, name="NoteTaker"
-)
-
-chart_generating_agent = create_agent(
-    llm,
-    [read_document],
-    "You are a data viz expert tasked with generating charts for a research project."
-    "{current_files}",
-)
-context_aware_chart_generating_agent = prelude | chart_generating_agent
-chart_generating_node = functools.partial(
-    agent_node, agent=context_aware_chart_generating_agent, name="ChartGenerator"
-)
-
-doc_writing_supervisor = create_team_supervisor(
-    llm,
-    "You are a supervisor tasked with managing a conversation between the"
-    " following workers: {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 finished,"
-    " respond with FINISH.",
-    ["DocWriter", "NoteTaker", "ChartGenerator"],
-)
-
-authoring_graph = StateGraph(DocWritingState)
-authoring_graph.add_node("DocWriter", doc_writing_node)
-authoring_graph.add_node("NoteTaker", note_taking_node)
-authoring_graph.add_node("ChartGenerator", chart_generating_node)
-authoring_graph.add_node("supervisor", doc_writing_supervisor)
-
-authoring_graph.add_edge("DocWriter", "supervisor")
-authoring_graph.add_edge("NoteTaker", "supervisor")
-authoring_graph.add_edge("ChartGenerator", "supervisor")
-authoring_graph.add_conditional_edges(
-    "supervisor",
-    lambda x: x["next"],
-    {
-        "DocWriter": "DocWriter",
-        "NoteTaker": "NoteTaker",
-        "ChartGenerator": "ChartGenerator",
-        "FINISH": END,
-    },
-)
-
-authoring_graph.add_edge(START, "supervisor")
-chain = authoring_graph.compile()
-
-def enter_chain(message: str, members: List[str]):
-    results = {
-        "messages": [HumanMessage(content=message)],
-        "team_members": ", ".join(members),
-    }
-    return results
-
-authoring_chain = (
-    functools.partial(enter_chain, members=authoring_graph.nodes)
-    | authoring_graph.compile()
-)
-
-supervisor_node = create_team_supervisor(
-    llm,
-    "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. Make sure each team is used atleast once. When finished,"
-    " respond with FINISH.",
-    ["ResearchTeam", "PaperWritingTeam"],
-)
-
-class State(TypedDict):
-    messages: Annotated[List[BaseMessage], operator.add]
-    next: str
-
-def get_last_message(state: State) -> str:
-    return state["messages"][-1].content
-
-def join_graph(response: dict):
-    return {"messages": [response["messages"][-1]]}
-
-super_graph = StateGraph(State)
-super_graph.add_node("ResearchTeam", get_last_message | research_chain | join_graph)
-super_graph.add_node("PaperWritingTeam", get_last_message | authoring_chain | join_graph)
-super_graph.add_node("supervisor", supervisor_node)
-
-super_graph.add_edge("ResearchTeam", "supervisor")
-super_graph.add_edge("PaperWritingTeam", "supervisor")
-super_graph.add_conditional_edges(
-    "supervisor",
-    lambda x: x["next"],
-    {
-        "PaperWritingTeam": "PaperWritingTeam",
-        "ResearchTeam": "ResearchTeam",
-        "FINISH": END,
-    },
-)
-super_graph.add_edge(START, "supervisor")
-super_graph = super_graph.compile()
-
-# Streamlit UI
-input_text = st.text_input("Enter your query:")
-
-if input_text:
-    if not openai_api_key or not tavily_api_key:
-        st.error("Please provide both OpenAI and Tavily API keys in the sidebar.")
-    else:
-        st.markdown("### 🛠️ Task Progress")
-        start_time = time.time()
-        max_execution_time = 300  # 5 minutes
-
-        try:
-            for s in super_graph.stream(
-                {
-                    "messages": [
-                        HumanMessage(
-                            content=input_text
-                        )
-                    ],
-                },
-                {"recursion_limit": 300},  # Increased recursion limit
-            ):
-                if "__end__" not in s:
-                    st.write(s)
-                    st.write("---")
-                
-                # Check for timeout
-                if time.time() - start_time > max_execution_time:
-                    st.warning("Execution time exceeded. Terminating the process.")
-                    break
-        except Exception as e:
-            st.error(f"An error occurred: {str(e)}")
-            logger.error(f"Error in super_graph execution: {str(e)}")
-
-if st.button("List Output Files"):
-    files = os.listdir(WORKING_DIRECTORY)
-    if files:
-        st.write("### 📂 Files in working directory:")
-        for file in files:
-            st.write(f"📄 {file}")
-    else:
-        st.write("No files found in the working directory.")
-
-output_files = os.listdir(WORKING_DIRECTORY)
-if output_files:
-    output_file = st.selectbox("Select an output file to download:", output_files)
-
-    if st.button("Download Output Document"):
-        file_path = WORKING_DIRECTORY / output_file
-        if file_path.exists():
-            with file_path.open("rb") as file:
-                st.download_button(
-                    label="📥 Download Output Document",
-                    data=file,
-                    file_name=output_file,
-                )
-        else:
-            st.write("Output document not found.")
-else:
-    st.write("No output files available for download.")
-
-# Cleanup
-if st.button("Clear Working Directory"):
-    for file in WORKING_DIRECTORY.iterdir():
-        if file.is_file():
-            file.unlink()
-    st.success("Working directory cleared.")