Merge pull request #3 from JulsdL/Flashcards_implementation

.chainlit/config.toml

@@ -1,109 +0,0 @@
-[project]
-# Whether to enable telemetry (default: true). No personal data is collected.
-enable_telemetry = true
-
-
-# List of environment variables to be provided by each user to use the app.
-user_env = []
-
-# Duration (in seconds) during which the session is saved when the connection is lost
-session_timeout = 3600
-
-# Enable third parties caching (e.g LangChain cache)
-cache = false
-
-# Authorized origins
-allow_origins = ["*"]
-
-# Follow symlink for asset mount (see https://github.com/Chainlit/chainlit/issues/317)
-# follow_symlink = false
-
-[features]
-# Show the prompt playground
-prompt_playground = true
-
-# Process and display HTML in messages. This can be a security risk (see https://stackoverflow.com/questions/19603097/why-is-it-dangerous-to-render-user-generated-html-or-javascript)
-unsafe_allow_html = false
-
-# Process and display mathematical expressions. This can clash with "$" characters in messages.
-latex = false
-
-# Automatically tag threads with the current chat profile (if a chat profile is used)
-auto_tag_thread = true
-
-# Authorize users to upload files with messages
-[features.multi_modal]
-    enabled = true
-    accept = ["*/*"]
-    max_files = 20
-    max_size_mb = 500
-
-# Allows user to use speech to text
-[features.speech_to_text]
-    enabled = false
-    # See all languages here https://github.com/JamesBrill/react-speech-recognition/blob/HEAD/docs/API.md#language-string
-    # language = "en-US"
-
-[UI]
-# Name of the app and chatbot.
-name = "Chatbot"
-
-# Show the readme while the thread is empty.
-show_readme_as_default = true
-
-# Description of the app and chatbot. This is used for HTML tags.
-# description = ""
-
-# Large size content are by default collapsed for a cleaner ui
-default_collapse_content = true
-
-# The default value for the expand messages settings.
-default_expand_messages = false
-
-# Hide the chain of thought details from the user in the UI.
-hide_cot = false
-
-# Link to your github repo. This will add a github button in the UI's header.
-# github = ""
-
-# Specify a CSS file that can be used to customize the user interface.
-# The CSS file can be served from the public directory or via an external link.
-# custom_css = "/public/test.css"
-
-# Specify a Javascript file that can be used to customize the user interface.
-# The Javascript file can be served from the public directory.
-# custom_js = "/public/test.js"
-
-# Specify a custom font url.
-# custom_font = "https://fonts.googleapis.com/css2?family=Inter:wght@400;500;700&display=swap"
-
-# Specify a custom build directory for the frontend.
-# This can be used to customize the frontend code.
-# Be careful: If this is a relative path, it should not start with a slash.
-# custom_build = "./public/build"
-
-# Override default MUI light theme. (Check theme.ts)
-[UI.theme]
-    #font_family = "Inter, sans-serif"
-[UI.theme.light]
-    #background = "#FAFAFA"
-    #paper = "#FFFFFF"
-
-    [UI.theme.light.primary]
-        #main = "#F80061"
-        #dark = "#980039"
-        #light = "#FFE7EB"
-
-# Override default MUI dark theme. (Check theme.ts)
-[UI.theme.dark]
-    #background = "#FAFAFA"
-    #paper = "#FFFFFF"
-
-    [UI.theme.dark.primary]
-        #main = "#F80061"
-        #dark = "#980039"
-        #light = "#FFE7EB"
-
-
-[meta]
-generated_by = "1.0.506"

.chainlit/translations/en-US.json

@@ -1,231 +0,0 @@
-{
-    "components": {
-        "atoms": {
-            "buttons": {
-                "userButton": {
-                    "menu": {
-                        "settings": "Settings",
-                        "settingsKey": "S",
-                        "APIKeys": "API Keys",
-                        "logout": "Logout"
-                    }
-                }
-            }
-        },
-        "molecules": {
-            "newChatButton": {
-                "newChat": "New Chat"
-            },
-            "tasklist": {
-                "TaskList": {
-                    "title": "\ud83d\uddd2\ufe0f Task List",
-                    "loading": "Loading...",
-                    "error": "An error occured"
-                }
-            },
-            "attachments": {
-                "cancelUpload": "Cancel upload",
-                "removeAttachment": "Remove attachment"
-            },
-            "newChatDialog": {
-                "createNewChat": "Create new chat?",
-                "clearChat": "This will clear the current messages and start a new chat.",
-                "cancel": "Cancel",
-                "confirm": "Confirm"
-            },
-            "settingsModal": {
-                "settings": "Settings",
-                "expandMessages": "Expand Messages",
-                "hideChainOfThought": "Hide Chain of Thought",
-                "darkMode": "Dark Mode"
-            },
-            "detailsButton": {
-                "using": "Using",
-                "running": "Running",
-                "took_one": "Took {{count}} step",
-                "took_other": "Took {{count}} steps"
-            },
-            "auth": {
-                "authLogin": {
-                    "title": "Login to access the app.",
-                    "form": {
-                        "email": "Email address",
-                        "password": "Password",
-                        "noAccount": "Don't have an account?",
-                        "alreadyHaveAccount": "Already have an account?",
-                        "signup": "Sign Up",
-                        "signin": "Sign In",
-                        "or": "OR",
-                        "continue": "Continue",
-                        "forgotPassword": "Forgot password?",
-                        "passwordMustContain": "Your password must contain:",
-                        "emailRequired": "email is a required field",
-                        "passwordRequired": "password is a required field"
-                    },
-                    "error": {
-                        "default": "Unable to sign in.",
-                        "signin": "Try signing in with a different account.",
-                        "oauthsignin": "Try signing in with a different account.",
-                        "redirect_uri_mismatch": "The redirect URI is not matching the oauth app configuration.",
-                        "oauthcallbackerror": "Try signing in with a different account.",
-                        "oauthcreateaccount": "Try signing in with a different account.",
-                        "emailcreateaccount": "Try signing in with a different account.",
-                        "callback": "Try signing in with a different account.",
-                        "oauthaccountnotlinked": "To confirm your identity, sign in with the same account you used originally.",
-                        "emailsignin": "The e-mail could not be sent.",
-                        "emailverify": "Please verify your email, a new email has been sent.",
-                        "credentialssignin": "Sign in failed. Check the details you provided are correct.",
-                        "sessionrequired": "Please sign in to access this page."
-                    }
-                },
-                "authVerifyEmail": {
-                    "almostThere": "You're almost there! We've sent an email to ",
-                    "verifyEmailLink": "Please click on the link in that email to complete your signup.",
-                    "didNotReceive": "Can't find the email?",
-                    "resendEmail": "Resend email",
-                    "goBack": "Go Back",
-                    "emailSent": "Email sent successfully.",
-                    "verifyEmail": "Verify your email address"
-                },
-                "providerButton": {
-                    "continue": "Continue with {{provider}}",
-                    "signup": "Sign up with {{provider}}"
-                },
-                "authResetPassword": {
-                    "newPasswordRequired": "New password is a required field",
-                    "passwordsMustMatch": "Passwords must match",
-                    "confirmPasswordRequired": "Confirm password is a required field",
-                    "newPassword": "New password",
-                    "confirmPassword": "Confirm password",
-                    "resetPassword": "Reset Password"
-                },
-                "authForgotPassword": {
-                    "email": "Email address",
-                    "emailRequired": "email is a required field",
-                    "emailSent": "Please check the email address {{email}} for instructions to reset your password.",
-                    "enterEmail": "Enter your email address and we will send you instructions to reset your password.",
-                    "resendEmail": "Resend email",
-                    "continue": "Continue",
-                    "goBack": "Go Back"
-                }
-            }
-        },
-        "organisms": {
-            "chat": {
-                "history": {
-                    "index": {
-                        "showHistory": "Show history",
-                        "lastInputs": "Last Inputs",
-                        "noInputs": "Such empty...",
-                        "loading": "Loading..."
-                    }
-                },
-                "inputBox": {
-                    "input": {
-                        "placeholder": "Type your message here..."
-                    },
-                    "speechButton": {
-                        "start": "Start recording",
-                        "stop": "Stop recording"
-                    },
-                    "SubmitButton": {
-                        "sendMessage": "Send message",
-                        "stopTask": "Stop Task"
-                    },
-                    "UploadButton": {
-                        "attachFiles": "Attach files"
-                    },
-                    "waterMark": {
-                        "text": "Built with"
-                    }
-                },
-                "Messages": {
-                    "index": {
-                        "running": "Running",
-                        "executedSuccessfully": "executed successfully",
-                        "failed": "failed",
-                        "feedbackUpdated": "Feedback updated",
-                        "updating": "Updating"
-                    }
-                },
-                "dropScreen": {
-                    "dropYourFilesHere": "Drop your files here"
-                },
-                "index": {
-                    "failedToUpload": "Failed to upload",
-                    "cancelledUploadOf": "Cancelled upload of",
-                    "couldNotReachServer": "Could not reach the server",
-                    "continuingChat": "Continuing previous chat"
-                },
-                "settings": {
-                    "settingsPanel": "Settings panel",
-                    "reset": "Reset",
-                    "cancel": "Cancel",
-                    "confirm": "Confirm"
-                }
-            },
-            "threadHistory": {
-                "sidebar": {
-                    "filters": {
-                        "FeedbackSelect": {
-                            "feedbackAll": "Feedback: All",
-                            "feedbackPositive": "Feedback: Positive",
-                            "feedbackNegative": "Feedback: Negative"
-                        },
-                        "SearchBar": {
-                            "search": "Search"
-                        }
-                    },
-                    "DeleteThreadButton": {
-                        "confirmMessage": "This will delete the thread as well as it's messages and elements.",
-                        "cancel": "Cancel",
-                        "confirm": "Confirm",
-                        "deletingChat": "Deleting chat",
-                        "chatDeleted": "Chat deleted"
-                    },
-                    "index": {
-                        "pastChats": "Past Chats"
-                    },
-                    "ThreadList": {
-                        "empty": "Empty...",
-                        "today": "Today",
-                        "yesterday": "Yesterday",
-                        "previous7days": "Previous 7 days",
-                        "previous30days": "Previous 30 days"
-                    },
-                    "TriggerButton": {
-                        "closeSidebar": "Close sidebar",
-                        "openSidebar": "Open sidebar"
-                    }
-                },
-                "Thread": {
-                    "backToChat": "Go back to chat",
-                    "chatCreatedOn": "This chat was created on"
-                }
-            },
-            "header": {
-                "chat": "Chat",
-                "readme": "Readme"
-            }
-        }
-    },
-    "hooks": {
-        "useLLMProviders": {
-            "failedToFetchProviders": "Failed to fetch providers:"
-        }
-    },
-    "pages": {
-        "Design": {},
-        "Env": {
-            "savedSuccessfully": "Saved successfully",
-            "requiredApiKeys": "Required API Keys",
-            "requiredApiKeysInfo": "To use this app, the following API keys are required. The keys are stored on your device's local storage."
-        },
-        "Page": {
-            "notPartOfProject": "You are not part of this project."
-        },
-        "ResumeButton": {
-            "resumeChat": "Resume Chat"
-        }
-    }
-}

.gitignore

@@ -82,10 +82,16 @@ target/
 profile_default/
 ipython_config.py
 
+# FLashcard directory
+flashcards/
+
+# .chainlit directory
+.chainlit/
+
 # pyenv
 #   For a library or package, you might want to ignore these files since the code is
 #   intended to run in multiple environments; otherwise, check them in:
-# .python-version
+.python-version
 
 # pipenv
 #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.

README.md

@@ -1,8 +1,8 @@
-# AIMS-Tutor
+# AI-Notebook-Tutor
 
 # RAG Application for QA in Jupyter Notebook
 
-AIMS-Tutor is designed to provide question-answering capabilities in a Jupyter Notebook using the Retrieval Augmented Generation (RAG) model. It's built on top of the LangChain and Chainlit platforms, and it uses the OpenAI API for the chat model.
+AI-Notebook-Tutor is designed to provide question-answering capabilities in a Jupyter Notebook using the Retrieval Augmented Generation (RAG) model. It's built on top of the LangChain and Chainlit platforms, and it uses the OpenAI API for the chat model.
 
 ## Features
 
@@ -28,7 +28,7 @@ OPENAI_API_KEY=your-key-here
 4. Run the application using the following command:
 
 ```bash
-chainlit run aims_tutor/app.py
+chainlit run notebook_tutor/app.py
 ```
 
 ## Usage

flashcards_cca7854c-91c2-47d5-872f-46132739ace0.csv

@@ -0,0 +1,11 @@
+Front,Back
+What command is used to clone a GitHub repository in a notebook?,!git clone https://github.com/arcee-ai/DALM
+How do you install or upgrade a Python package in a notebook?,!pip install --upgrade -q -e .
+Which command installs the 'langchain' and 'langchain-community' libraries?,!pip install -qU langchain langchain-core langchain-community sentence_transformers
+What is the command to install 'pymupdf' and 'faiss-cpu'?,!pip install -qU pymupdf faiss-cpu
+How do you import the Pandas library in Python?,import pandas as pd
+Which library provides the 'HuggingFaceEmbeddings' class?,from langchain_community.embeddings import HuggingFaceEmbeddings
+How do you import the 'FAISS' vector store from the 'langchain_community' library?,from langchain_community.vectorstores import FAISS
+What is the import statement for reading directories using the 'Llama Index' library?,from llama_index.core import SimpleDirectoryReader
+Which import statement is used for parsing nodes in the 'Llama Index' library?,from llama_index.core.node_parser import SimpleNodeParser
+How do you import the 'MetadataMode' schema from the 'Llama Index' library?,from llama_index.core.schema import MetadataMode

main.py

@@ -1,118 +0,0 @@
-import os
-from operator import itemgetter
-
-import chainlit as cl
-import tiktoken
-from dotenv import load_dotenv
-
-
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.retrievers import MultiQueryRetriever
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.runnables import RunnablePassthrough
-from langchain_community.document_loaders import PyMuPDFLoader, PythonLoader, NotebookLoader
-from langchain_community.vectorstores import Qdrant
-from langchain_openai import ChatOpenAI
-from langchain_openai.embeddings import OpenAIEmbeddings
-
-# Load environment variables
-load_dotenv()
-
-# Configuration for OpenAI
-OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
-openai_chat_model = ChatOpenAI(model="gpt-4-turbo", temperature=0.1)
-
-# Define the RAG prompt
-RAG_PROMPT = """
-CONTEXT:
-{context}
-
-QUERY:
-{question}
-
-Answer the query in a pretty format if the context is related to it; otherwise, answer: 'Sorry, I can't answer.'
-"""
-rag_prompt = ChatPromptTemplate.from_template(RAG_PROMPT)
-
-
-# ChainLit setup for chat interaction
-@cl.on_chat_start
-async def start_chat():
-    settings = {
-        "model": "gpt-3.5-turbo",
-        "temperature": 0,
-        "top_p": 1,
-        "frequency_penalty": 0,
-        "presence_penalty": 0,
-    }
-    cl.user_session.set("settings", settings)
-
-    # Display a welcoming message with instructions
-    welcome_message = "Welcome to the AIMS-Tutor! Please upload a Jupyter notebook (.ipynb and max. 5mb) to start."
-    await cl.Message(content=welcome_message).send()
-
-    # Wait for the user to upload a file
-    files = None
-    while files is None:
-        files = await cl.AskFileMessage(
-            content="Please upload a Jupyter notebook (.ipynb, max. 5mb):",
-            accept={"application/x-ipynb+json": [".ipynb"]},
-            max_size_mb=5
-        ).send()
-
-    file = files[0] # Get the first file
-
-    if file:
-        # Load the Jupyter notebook
-        notebook_path = file.path # Extract the path from the AskFileResponse object
-
-        loader = NotebookLoader(
-            notebook_path,
-            include_outputs=False,
-            max_output_length=20,
-            remove_newline=True,
-            traceback=False
-        )
-        docs = loader.load()
-        cl.user_session.set("docs", docs) # Store the docs in the user session
-
-        # Initialize the retriever components after loading document
-        text_splitter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=50, length_function=tiktoken_len) # Initialize the text splitter
-        split_chunks = text_splitter.split_documents(docs) # Split the documents into chunks
-        embedding_model = OpenAIEmbeddings(model="text-embedding-3-small") # Initialize the embedding model
-        qdrant_vectorstore = Qdrant.from_documents(split_chunks, embedding_model, location=":memory:", collection_name="Notebook") # Create a Qdrant vector store
-        qdrant_retriever = qdrant_vectorstore.as_retriever() # Set the Qdrant vector store as a retriever
-        multiquery_retriever = MultiQueryRetriever.from_llm(retriever=qdrant_retriever, llm=openai_chat_model, include_original=True) # Create a multi-query retriever on top of the Qdrant retriever
-
-        # Store the multiquery_retriever in the user session
-        cl.user_session.set("multiquery_retriever", multiquery_retriever)
-
-
-@cl.on_message
-async def main(message: cl.Message):
-    # Retrieve the multi-query retriever from session
-    multiquery_retriever = cl.user_session.get("multiquery_retriever")
-    if not multiquery_retriever:
-        await cl.Message(content="No document processing setup found. Please upload a Jupyter notebook first.").send()
-        return
-
-    question = message.content
-    response = handle_query(question, multiquery_retriever)  # Process the question
-
-    msg = cl.Message(content=response)
-    await msg.send()
-
-def handle_query(question, retriever):
-    # Define the retrieval augmented query-answering chain
-    retrieval_augmented_qa_chain = (
-        {"context": itemgetter("question") | retriever, "question": itemgetter("question")}
-        | RunnablePassthrough.assign(context=itemgetter("context"))
-        | {"response": rag_prompt | openai_chat_model, "context": itemgetter("context")}
-    )
-    response = retrieval_augmented_qa_chain.invoke({"question": question})
-    return response["response"].content
-
-# Tokenization function
-def tiktoken_len(text):
-    tokens = tiktoken.encoding_for_model("gpt-3.5-turbo").encode(text)
-    return len(tokens)

aims_tutor/graph.py → notebook_tutor/agents.py

@@ -1,37 +1,24 @@
-from typing import Annotated, List, TypedDict
-from dotenv import load_dotenv
+from typing import Annotated
 from langchain_core.tools import tool
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain_core.messages import AIMessage, BaseMessage
+from langchain_core.messages import AIMessage
 from langchain.agents import AgentExecutor, create_openai_functions_agent
 from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
 from langchain_openai import ChatOpenAI
-from langgraph.graph import END, StateGraph
-import functools
+from tools import create_flashcards_tool, RetrievalChainWrapper
 
-# Load environment variables
-load_dotenv()
 
 # Instantiate the language model
 llm = ChatOpenAI(model="gpt-4o")
 
-class RetrievalChainWrapper:
-    def __init__(self, retrieval_chain):
-        self.retrieval_chain = retrieval_chain
-
-    def retrieve_information(
-        self,
-        query: Annotated[str, "query to ask the RAG tool"]
-    ):
-        """Use this tool to retrieve information about the provided notebook."""
-        response = self.retrieval_chain.invoke({"question": query})
-        return response["response"].content
-
-# Create an instance of the wrapper
+# Function to create an instance of the retrieval tool wrapper
 def get_retrieve_information_tool(retrieval_chain):
     wrapper_instance = RetrievalChainWrapper(retrieval_chain)
     return tool(wrapper_instance.retrieve_information)
 
+# Instantiate the flashcard tool
+flashcard_tool = create_flashcards_tool
+
 # Function to create agents
 def create_agent(
     llm: ChatOpenAI,
@@ -60,19 +47,21 @@ def create_agent(
 # Function to create agent nodes
 def agent_node(state, agent, name):
     result = agent.invoke(state)
-    if 'messages' not in result: # Check if messages are present in the agent state
+    if 'messages' not in result:
         raise ValueError(f"No messages found in agent state: {result}")
     new_state = {"messages": state["messages"] + [AIMessage(content=result["output"], name=name)]}
-    if "next" in result:
-        new_state["next"] = result["next"]
-    if name == "QuizAgent" and "quiz_created" in state and not state["quiz_created"]:
+
+    # Set the appropriate flags and next state
+    if name == "QuizAgent":
         new_state["quiz_created"] = True
-        new_state["next"] = "FINISH" # Finish the conversation after the quiz is created and wait for a new user input
+
     if name == "QAAgent":
         new_state["question_answered"] = True
-        new_state["next"] = "question_answered"
-    return new_state
 
+    if name == "FlashcardsAgent":
+        new_state["flashcards_created"] = True
+
+    return new_state
 
 # Function to create the supervisor
 def create_team_supervisor(llm: ChatOpenAI, system_prompt, members) -> AgentExecutor:
@@ -111,65 +100,3 @@ def create_team_supervisor(llm: ChatOpenAI, system_prompt, members) -> AgentExec
         | llm.bind_functions(functions=[function_def], function_call="route")
         | JsonOutputFunctionsParser()
     )
-
-# Define the state for the system
-class AIMSState(TypedDict):
-    messages: List[BaseMessage]
-    next: str
-    quiz: List[dict]
-    quiz_created: bool
-    question_answered: bool
-
-
-# Create the LangGraph chain
-def create_aims_chain(retrieval_chain):
-
-    retrieve_information_tool = get_retrieve_information_tool(retrieval_chain)
-
-    # Create QA Agent
-    qa_agent = create_agent(
-        llm,
-        [retrieve_information_tool],
-        "You are a QA assistant who answers questions about the provided notebook content.",
-    )
-
-    qa_node = functools.partial(agent_node, agent=qa_agent, name="QAAgent")
-
-    # Create Quiz Agent
-    quiz_agent = create_agent(
-        llm,
-        [retrieve_information_tool],
-        "You are a quiz creator that generates quizzes based on the provided notebook content."
-
-        """First, You MUST Use the retrieval_inforation_tool to gather context from the notebook to gather relevant and accurate information.
-
-        Next, create a 5-question quiz based on the information you have gathered. Include the answers at the end of the quiz.
-
-        Present the quiz to the user in a clear and concise manner."""
-    )
-
-    quiz_node = functools.partial(agent_node, agent=quiz_agent, name="QuizAgent")
-
-    # Create Supervisor Agent
-    supervisor_agent = create_team_supervisor(
-        llm,
-        "You are a supervisor tasked with managing a conversation between the following agents: QAAgent, QuizAgent. Given the user request, decide which agent should act next.",
-        ["QAAgent", "QuizAgent"],
-    )
-
-    # Build the LangGraph
-    aims_graph = StateGraph(AIMSState)
-    aims_graph.add_node("QAAgent", qa_node)
-    aims_graph.add_node("QuizAgent", quiz_node)
-    aims_graph.add_node("supervisor", supervisor_agent)
-
-    aims_graph.add_edge("QAAgent", "supervisor")
-    aims_graph.add_edge("QuizAgent", "supervisor")
-    aims_graph.add_conditional_edges(
-        "supervisor",
-        lambda x: "FINISH" if x.get("quiz_created") else ("FINISH" if x.get("question_answered") else x["next"]),
-        {"QAAgent": "QAAgent", "QuizAgent": "QuizAgent", "WAIT": END, "FINISH": END, "question_answered": END},
-    )
-
-    aims_graph.set_entry_point("supervisor")
-    return aims_graph.compile()

{aims_tutor → notebook_tutor}/app.py

@@ -1,6 +1,6 @@
 import os
 from dotenv import load_dotenv
-import aims_tutor.chainlit_frontend as cl_frontend
+import notebook_tutor.chainlit_frontend as cl_frontend
 
 # Load environment variables
 load_dotenv()

{aims_tutor → notebook_tutor}/chainlit_frontend.py

@@ -1,30 +1,38 @@
+import os
+import logging
 import chainlit as cl
 from dotenv import load_dotenv
 from document_processing import DocumentManager
 from retrieval import RetrievalManager
 from langchain_core.messages import AIMessage, HumanMessage
-from graph import create_aims_chain, AIMSState
+from graph import create_tutor_chain, TutorState
+import shutil
 
 # Load environment variables
 load_dotenv()
 
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+
+logger = logging.getLogger(__name__)
+
 @cl.on_chat_start
 async def start_chat():
     settings = {
-        "model": "gpt-3.5-turbo",
+        "model": "gpt4o",
         "temperature": 0,
         "top_p": 1,
         "frequency_penalty": 0,
         "presence_penalty": 0,
     }
     cl.user_session.set("settings", settings)
-    welcome_message = "Welcome to the AIMS-Tutor! Please upload a Jupyter notebook (.ipynb and max. 5mb) to start."
+    welcome_message = "Welcome to the Notebook-Tutor!"
     await cl.Message(content=welcome_message).send()
 
     files = None
     while files is None:
         files = await cl.AskFileMessage(
-            content="Please upload a Jupyter notebook (.ipynb, max. 5mb):",
+            content="Please upload a Jupyter notebook (.ipynb, max. 5mb) to start:",
             accept={"application/x-ipynb+json": [".ipynb"]},
             max_size_mb=5
         ).send()
@@ -42,48 +50,92 @@ async def start_chat():
         # Initialize LangGraph chain with the retrieval chain
         retrieval_chain = cl.user_session.get("retrieval_manager").get_RAG_QA_chain()
         cl.user_session.set("retrieval_chain", retrieval_chain)
-        aims_chain = create_aims_chain(retrieval_chain)
-        cl.user_session.set("aims_chain", aims_chain)
+        tutor_chain = create_tutor_chain(retrieval_chain)
+        cl.user_session.set("tutor_chain", tutor_chain)
+
+        ready_to_chat_message = "Notebook uploaded and processed successfully. You are now ready to chat!"
+        await cl.Message(content=ready_to_chat_message).send()
+
+        logger.info("Chat started and notebook uploaded successfully.")
 
 @cl.on_message
 async def main(message: cl.Message):
+
     # Retrieve the LangGraph chain from the session
-    aims_chain = cl.user_session.get("aims_chain")
+    tutor_chain = cl.user_session.get("tutor_chain")
 
-    if not aims_chain:
+    if not tutor_chain:
         await cl.Message(content="No document processing setup found. Please upload a Jupyter notebook first.").send()
         return
 
     # Create the initial state with the user message
     user_message = message.content
-    state = AIMSState(messages=[HumanMessage(content=user_message)], next="supervisor", quiz=[], quiz_created=False, question_answered=False)
-
+    state = TutorState(
+        messages=[HumanMessage(content=user_message)],
+        next="supervisor",
+        quiz=[],
+        quiz_created=False,
+        question_answered=False,
+        flashcards_created=False,
+    )
 
-    print(f"Initial state: {state}")
+    logger.info(f"Initial state: {state}")
 
     # Process the message through the LangGraph chain
-    for s in aims_chain.stream(state, {"recursion_limit": 10}):
-        print(f"State after processing: {s}")
-
-        # Extract messages from the state
-        if "__end__" not in s:
-            agent_state = next(iter(s.values()))
-            if "messages" in agent_state:
-                response = agent_state["messages"][-1].content
-                print(f"Response: {response}")
-                await cl.Message(content=response).send()
-            else:
-                print("Error: No messages found in agent state.")
-        else:
-            # Check if the quiz was created and send it to the frontend
-            if state["quiz_created"]:
-                quiz_message = state["messages"][-1].content
-                await cl.Message(content=quiz_message).send()
-            # Check if a question was answered and send the response to the frontend
-            if state["question_answered"]:
-                qa_message = state["messages"][-1].content
+    for s in tutor_chain.stream(state, {"recursion_limit": 10}):
+        logger.info(f"State after processing: {s}")
+
+        agent_state = next(iter(s.values()))
+
+        if "QAAgent" in s:
+            if s['QAAgent']['question_answered']:
+                qa_message = agent_state["messages"][-1].content
+                logger.info(f"Sending QAAgent message: {qa_message}")
                 await cl.Message(content=qa_message).send()
 
-            print("Reached end state.")
+        if "QuizAgent" in s:
+            if s['QuizAgent']['quiz_created']:
+                quiz_message = agent_state["messages"][-1].content
+                logger.info(f"Sending QuizAgent message: {quiz_message}")
+                await cl.Message(content=quiz_message).send()
+
+        if "FlashcardsAgent" in s:
+            if s['FlashcardsAgent']['flashcards_created']:
+                flashcards_message = agent_state["messages"][-1].content
+                logger.info(f"Sending FlashcardsAgent message: {flashcards_message}")
+                await cl.Message(content=flashcards_message).send()
+
+                # Search for the flashcard file in the specified directory
+                flashcard_directory = 'flashcards'
+                flashcard_file = None
+                latest_time = 0
+                for root, dirs, files in os.walk(flashcard_directory):
+                    for file in files:
+                        if file.startswith('flashcards_') and file.endswith('.csv'):
+                            file_path = os.path.join(root, file)
+                            file_time = os.path.getmtime(file_path)
+                            if file_time > latest_time:
+                                latest_time = file_time
+                                flashcard_file = file_path
+
+                if flashcard_file:
+                    logger.info(f"Flashcard path: {flashcard_file}")
+                    # Use the File class to send the file
+                    file_element = cl.File(name="Flashcards", path=flashcard_file, display="inline")
+                    logger.info(f"Sending flashcards file: {file_element}")
+
+                    await cl.Message(
+                        content="Download the flashcards in .csv here:",
+                        elements=[file_element]
+                    ).send()
+
+    logger.info("Reached END state.")
+
 
-            break
+@cl.on_chat_end
+async def end_chat():
+    # Clean up the flashcards directory
+    flashcard_directory = 'flashcards'
+    if os.path.exists(flashcard_directory):
+        shutil.rmtree(flashcard_directory)
+        os.makedirs(flashcard_directory)

{aims_tutor → notebook_tutor}/document_processing.py

@@ -6,7 +6,7 @@ from langchain.retrievers import MultiQueryRetriever
 from langchain_openai.embeddings import OpenAIEmbeddings
 from langchain_openai import ChatOpenAI
 from dotenv import load_dotenv
-from aims_tutor.utils import tiktoken_len
+from notebook_tutor.utils import tiktoken_len
 
 # Load environment variables
 load_dotenv()

notebook_tutor/graph.py

@@ -0,0 +1,66 @@
+from dotenv import load_dotenv
+from langgraph.graph import END, StateGraph
+from states import TutorState
+from agents import create_agent, agent_node, create_team_supervisor, get_retrieve_information_tool, llm, flashcard_tool
+from prompt_templates import PromptTemplates
+import functools
+
+# Load environment variables
+load_dotenv()
+
+# Create the LangGraph chain
+def create_tutor_chain(retrieval_chain):
+    retrieve_information_tool = get_retrieve_information_tool(retrieval_chain)
+
+    # Create QA Agent
+    qa_agent = create_agent(
+        llm,
+        [retrieve_information_tool],
+        PromptTemplates().get_qa_agent_prompt(),
+    )
+    qa_node = functools.partial(agent_node, agent=qa_agent, name="QAAgent")
+
+    # Create Quiz Agent
+    quiz_agent = create_agent(
+        llm,
+        [retrieve_information_tool],
+        PromptTemplates().get_quiz_agent_prompt(),
+    )
+    quiz_node = functools.partial(agent_node, agent=quiz_agent, name="QuizAgent")
+
+    # Create Flashcards Agent
+    flashcards_agent = create_agent(
+        llm,
+        [retrieve_information_tool, flashcard_tool],
+        PromptTemplates().get_flashcards_agent_prompt(),
+    )
+    flashcards_node = functools.partial(agent_node, agent=flashcards_agent, name="FlashcardsAgent")
+
+    # Create Supervisor Agent
+    supervisor_agent = create_team_supervisor(
+        llm,
+        PromptTemplates().get_supervisor_agent_prompt(),
+        ["QAAgent", "QuizAgent", "FlashcardsAgent"],
+    )
+
+    # Build the LangGraph
+    tutor_graph = StateGraph(TutorState)
+    tutor_graph.add_node("QAAgent", qa_node)
+    tutor_graph.add_node("QuizAgent", quiz_node)
+    tutor_graph.add_node("FlashcardsAgent", flashcards_node)
+    tutor_graph.add_node("supervisor", supervisor_agent)
+
+    tutor_graph.add_edge("QAAgent", "supervisor")
+    tutor_graph.add_edge("QuizAgent", "supervisor")
+    tutor_graph.add_edge("FlashcardsAgent", "supervisor")
+    tutor_graph.add_conditional_edges(
+        "supervisor",
+        lambda x: "FINISH" if x.get("quiz_created") or x.get("question_answered") or x.get("flashcards_created") else x["next"],
+        {"QAAgent": "QAAgent",
+        "QuizAgent": "QuizAgent",
+        "FlashcardsAgent": "FlashcardsAgent",
+        "FINISH": END},
+    )
+
+    tutor_graph.set_entry_point("supervisor")
+    return tutor_graph.compile()

{aims_tutor → notebook_tutor}/prompt_templates.py

@@ -27,6 +27,36 @@ class PromptTemplates:
             Answer the query in a pretty format if the context is related to it; otherwise, answer: 'Sorry, I can't answer. Please ask another question.'
         """)
 
+        self.QAAgent_prompt = """"You are a QA assistant who answers questions about the provided notebook content.
+        Provide the notebook code and context to answer the user's questions accurately and informatively."""
+
+        self.QuizAgent_prompt = """You are a quiz creator that generates quizzes based on the provided notebook content.
+        First, You MUST Use the retrieval_inforation_tool to gather context from the notebook to gather relevant and accurate information.
+        Next, create a 5-question quiz based on the information you have gathered. Include the answers at the end of the quiz.
+        Present the quiz to the user in a clear and concise manner."""
+
+        self.FlashcardsAgent_prompt = """
+        You are the Flashcard creator. Your mission is to create effective and concise flashcards based on the user's query and the content of the provided notebook. Your role involves the following tasks:
+        1. Analyze User Query: Understand the user's request and determine the key concepts and information they need to learn.
+        2. Search Notebook Content: Use the notebook content to gather relevant information and generate accurate and informative flashcards.
+        3. Generate Flashcards: Create a series of flashcards content with clear questions on the front and detailed answers on the back. Ensure that the flashcards cover the essential points and concepts requested by the user.
+        4. Export Flashcards: YOU MUST USE the flashcard_tool to create and export the flashcards in a format that can be easily imported into a flashcard management system, such as Anki.
+        5. Provide the list of flashcards in a clear and organized manner.
+        Remember, your goal is to help the user learn efficiently and effectively by breaking down the notebook content into manageable, repeatable flashcards."""
+
+        self.SupervisorAgent_prompt = "You are a supervisor tasked with managing a conversation between the following agents: QAAgent, QuizAgent, FlashcardsAgent. Given the user request, decide which agent should act next."
+
     def get_rag_qa_prompt(self):
-        # Returns the RAG QA prompt
         return self.rag_QA_prompt
+
+    def get_qa_agent_prompt(self):
+        return self.QAAgent_prompt
+
+    def get_quiz_agent_prompt(self):
+        return self.QuizAgent_prompt
+
+    def get_flashcards_agent_prompt(self):
+        return self.FlashcardsAgent_prompt
+
+    def get_supervisor_agent_prompt(self):
+        return self.SupervisorAgent_prompt

notebook_tutor/states.py

@@ -0,0 +1,12 @@
+from typing import List, TypedDict
+from langchain_core.messages import BaseMessage
+
+# Define the state for the system
+class TutorState(TypedDict):
+    messages: List[BaseMessage]
+    next: str
+    quiz: List[dict]
+    quiz_created: bool
+    question_answered: bool
+    flashcards_created: bool
+    # flashcard_path: str

notebook_tutor/tools.py

@@ -0,0 +1,61 @@
+from typing import Optional, Type, Annotated
+from pydantic import BaseModel, Field
+from langchain.tools import BaseTool
+from langchain.callbacks.manager import (
+    AsyncCallbackManagerForToolRun,
+    CallbackManagerForToolRun,
+)
+import csv
+import uuid
+import os
+
+class FlashcardInput(BaseModel):
+    flashcards: list = Field(description="A list of flashcards. Each flashcard should be a dictionary with 'question' and 'answer' keys.")
+
+class FlashcardTool(BaseTool):
+    name = "create_flashcards"
+    description = "Create flashcards in a .csv format suitable for import into Anki"
+    args_schema: Type[BaseModel] = FlashcardInput
+
+    def _run(
+        self, flashcards: list, run_manager: Optional[CallbackManagerForToolRun] = None
+    ) -> str:
+        """Use the tool to create flashcards."""
+        filename = f"flashcards_{uuid.uuid4()}.csv"
+
+        save_path = os.path.join('flashcards', filename)
+
+        os.makedirs(os.path.dirname(save_path), exist_ok=True)
+
+        with open(save_path, 'w', newline='') as csvfile:
+            fieldnames = ['Front', 'Back']
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+
+            writer.writeheader()
+            for card in flashcards:
+                writer.writerow({'Front': card['question'], 'Back': card['answer']})
+
+        print("\033[93m" + f"Flashcards successfully created and saved to {save_path}" + "\033[0m")
+
+        return "csv file created successfully."
+
+    async def _arun(
+        self, flashcards: list, run_manager: Optional[AsyncCallbackManagerForToolRun] = None
+    ) -> str:
+        """Use the tool asynchronously."""
+        raise NotImplementedError("create_flashcards does not support async")
+
+# Instantiate the tool
+create_flashcards_tool = FlashcardTool()
+
+class RetrievalChainWrapper:
+    def __init__(self, retrieval_chain):
+        self.retrieval_chain = retrieval_chain
+
+    def retrieve_information(
+        self,
+        query: Annotated[str, "query to ask the RAG tool"]
+    ):
+        """Use this tool to retrieve information about the provided notebook."""
+        response = self.retrieval_chain.invoke({"question": query})
+        return response["response"].content