pip install python-dotenv langgraph langchain langchain_openai langchain_community langchain_text_splitters chromadb tavily-python openai typing_extensions termcolor

OPENAI_API_KEY={INSERT_YOUR_OPENAI_KEY}
TAVILY_API_KEY={INSERT_YOUR_TAVILY_KEY}

from langchain.prompts import ChatPromptTemplate
from langchain.llms import ChatOpenAI
from langchain.tools import TavilySearchResults
from langchain.chains import LLMChain
from langgraph import Command, State, TypedDict, Annotated, List

def resource_finder(state: State) -> Command[Literal["Supervisor"]]:
    """Finds resources based on the user's query."""
    query = state["messages"][-1].content
    context = state["messages"]

    # Define prompt
    prompt = ChatPromptTemplate.from_template(
        f"""You are a computer science resource finder. 
        You will find resources for the user based on their preferences 
        in the field of computer science and related topics. 
        Use the context to help you build the response. You may also answer
        general questions or miscellaneous queries.
        
        Question: {query}\n"""
    )
    
    # Define tool and bind LLM to Tavily tool
    tavily_tool = TavilySearchResults(max_results=5, search_depth="advanced", include_answer=True, include_raw_cnotallow=True)
    llm = ChatOpenAI(model="gpt-4o").bind_tools([tavily_tool])

    # Define LLM chain
    llm_chain = (
        prompt
        | llm
    )

    @chain
    def tool_chain(user_input: str, config: RunnableConfig):
        input_ = {"user_input": user_input, "context": context}
        ai_msg = llm_chain.invoke(input_, cnotallow=config)
        tool_msgs = tavily_tool.batch(ai_msg.tool_calls, cnotallow=config)
        return llm_chain.invoke({**input_, "messages": [ai_msg, *tool_msgs]}, cnotallow=config)

    response = tool_chain.invoke(query)

    return Command(
        update={
            "messages": [
                AIMessage(cnotallow=response.content, name="Resource-Finder")
            ]
        },
        goto="Supervisor",
    )

from langchain.loaders import CSVLoader
from langchain.text_splitters import RecursiveCharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.retrievers import VectorStoreRetriever
from langchain.prompts import ChatPromptTemplate
from langchain.llms import ChatOpenAI
from langchain.chains import LLMChain
from langgraph import Command, State, TypedDict, Annotated, List

def coding_problem_generator(state: State) -> Command[Literal["Supervisor"]]:
    """Generates a coding problem based on the user's query."""
    query = state["messages"][-1].content

    # Using LeetCode dataset for RAG to generate coding problems
    coding_dataset = "leetcode_dataset - lc.csv"

    # Load CSV file as input document
    loader = CSVLoader(file_path=coding_dataset)
    docs = loader.load()

    # Split documents into smaller chunks and store in Chroma vectorstore
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
    splits = text_splitter.split_documents(docs)
    vectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings())

    # Define retriever using vector store
    retriever = vectorstore.as_retriever()

    # Define prompt
    prompt = ChatPromptTemplate.from_template(
        """"You are a LeetCode-style coding problem generator. 
        You will generate a coding problem for the user to solve 
        based on their preferences. Use the context to help you build the problem.
        Do not provide a solution to the problem unless asked for.

        Context: {context}\n 
        Answer:"""
    )
    
    def format_docs(docs):
        return"\n\n".join(doc.page_content for doc in docs)

    # Define LLM model
    llm = ChatOpenAI(model="gpt-4o")
    
    # Build RAG chain using retriever, prompt, and LLM
    rag_chain = (
        {"context": retriever | format_docs}
        | prompt
        | llm
        | StrOutputParser()
    )

    # Invoke RAG chain to generate coding problem
    response = rag_chain.invoke(query)

    return Command(
        update={
            "messages": [
                AIMessage(cnotallow=response, name="Problem-Generator")
            ]
        },
        goto="Supervisor",
    )

from langgraph import Command, State, TypedDict, Annotated, List
from langchain.llms import ChatOpenAI

class Router(TypedDict):
    next: Literal["Resource-Finder", "Problem-Generator", "FINISH"]

def supervisor_agent(state: State) -> Command[Literal["Resource-Finder", "Problem-Generator", "__end__"]]:
    """Supervisor agent that manages the conversation between workers."""
    question = state["messages"][-1].content

    # Include the system prompt and the current conversation state in the messages
    members = ["Resource-Finder", "Problem-Generator"]
    system_prompt = (
            "You are a supervisor tasked with managing a conversation between the"
            f" following workers:  {members}. Given the following user request {question},"
            " respond with the worker to act next. Each worker will perform a"
            " task and respond with their results and status. When you determine a task to be finished,"
            " respond with FINISH."
            " Here are the uses of each worker:\n"
            "1. Resource-Finder: Find resources based on the user's query and handles any general or miscellaneous user queries.\n"
            "2. Problem-Generator: Generate a coding problem based on the user's query.\n"
        )

    messages = [
        {"role": "system", "content": system_prompt},
    ] + state["messages"]

    llm = ChatOpenAI(model="gpt-4o")

    # Use the LLM to decide the next step
    response = llm.with_structured_output(Router).invoke(messages)

    # Extract the next node from the response
    next_node = response.get("next", None)

    ifnot next_node:
        raise ValueError("Supervisor failed to determine the next step.")

    if next_node == "FINISH":
        next_node = "__end__"
    # Return a Command with the target node in the goto field.
    return Command(goto=next_node, update={"next": next_node})

from langgraph import StateGraph, START, END
import os
from dotenv import load_dotenv
from termcolor import colored

# Load environment variables
load_dotenv()

# Define the graph state
class State(TypedDict):
    messages: Annotated[List, add_messages] = []    
    next: str = ""

# Create the state graph
def create_graph():
    workflow = StateGraph(State)

    workflow.add_node("Resource-Finder", resource_finder)
    workflow.add_node("Problem-Generator", coding_problem_generator)
    workflow.add_node("Supervisor", supervisor_agent)

    workflow.add_edge(START, "Supervisor")

    graph = workflow.compile()

    return graph

# Main function to run the graph
def main():
    # Create the state graph
    graph = create_graph()

    # Print out the LangGraph as ASCII
    graph.get_graph().print_ascii()

    # Continuous input and LLM interaction
    print(colored("You can start interacting with the coding assistant. Type 'exit' to end the conversation.", "blue"))

    whileTrue:
        user_message = input("> ")

        if user_message == "exit":
            print(colored("Goodbye!", "blue"))
            break

        input_state = {"messages": [{"role": "user", "content": user_message}]}

        # Verbose output
        for event in graph.stream(input_state):
            print(colored(event, "red"))
            print("------------------------------------")

        # # Concise output
        # final_state = graph.invoke(input_state, config)
        # print(colored(final_state["messages"][-1].content, "red"))
        # print("------------------------------------")


if __name__ == "__main__":
    main()