updated to us vectara-agent

app.py

@@ -4,23 +4,14 @@ import streamlit as st
 import os
 from PIL import Image
 import re
-from translate import Translator
-from pydantic import Field
 import sys
+import datetime
 
-from llama_index.indices.managed.vectara import VectaraIndex
-from llama_index.core.agent import ReActAgent
-from llama_index.llms.openai import OpenAI
-from llama_index.core.tools import QueryEngineTool, ToolMetadata
-from llama_index.core.utils import print_text
-from llama_index.core.agent.react.formatter import ReActChatFormatter
+from pydantic import Field, BaseModel
+from vectara_agent.agent import Agent, AgentType, AgentStatusType
+from vectara_agent.tools import ToolsFactory
+from vectara_agent.tools_catalog import rephrase_text
 
-from llama_index.core.agent import ReActAgent
-from llama_index.agent.openai import OpenAIAgent
-from llama_index.core.tools import FunctionTool
-
-
-from prompts import prompt_template
 
 teaching_styles = ['traditional', 'Inquiry-based', 'Socratic']
 languages = {'English': 'en', 'Spanish': 'es', 'French': 'fr', 'German': 'de', 'Arabic': 'ar', 'Chinese': 'zh-cn', 
@@ -28,76 +19,94 @@ languages = {'English': 'en', 'Spanish': 'es', 'French': 'fr', 'German': 'de', '
 initial_prompt = "How can I help you today?"
 
 
-def launch_bot(agent_type: str):
+def create_tools(cfg):        
+
+    def adjust_response_to_student(
+            text: str = Field(description='the original text.'), 
+            age: int = Field(description='the age of the student. An integer'), 
+            style: str = Field(description='teaching style'), 
+            language: str = Field(description='the language')
+
+        ) -> str:
+        """
+        Rephrase the text to match the student's age, desired teaching style and language
+        """
+        instructions = f'''
+        The following is response the teacher is planning to provide to a student based on their question.
+        Please adjust the response to match the student's age of {age}, the {style} teaching style.
+        For example, in the inquiry-based teaching style, choose to ask questions that encourage the student to think critically instead of repsonding directly with the answer.
+        Or in the socratic teaching style, choose to ask questions that lead the student to the answer.
+        Always respond in the {language} language.''' \
+            .replace("{style}", cfg.style) \
+            .replace("{language}", cfg.language) \
+            .replace("{student_age}", str(cfg.student_age))
+
+        return rephrase_text(text, instructions)
+
+
+    class JusticeHarvardArgs(BaseModel):
+        query: str = Field(..., description="The user query.")
+
+    tools_factory = ToolsFactory(vectara_api_key=cfg.api_key, 
+                                 vectara_customer_id=cfg.customer_id, 
+                                 vectara_corpus_id=cfg.corpus_id)
+    query_tool = tools_factory.create_rag_tool(
+        tool_name = "justice_harvard_query",
+        tool_description = """
+        Given a user query, returns a response (str) based on the content of the Justice Harvard lecture transcripts.
+        It can answer questions about the justice, morality, politics and related topics,
+        based on transcripts of recordings from the Justice Harvard class that includes a lot of content on these topics.
+        When using the tool it's best to ask simple short questions. You can break complex questions into sub-queries.
+        """,
+        tool_args_schema = JusticeHarvardArgs,
+        tool_filter_template = '',
+        reranker = "multilingual_reranker_v1", rerank_k = 100, 
+        n_sentences_before = 2, n_sentences_after = 2, lambda_val = 0.01,
+        summary_num_results = 10,
+        vectara_summarizer = 'vectara-summary-ext-24-05-med-omni',
+    )
+
+    return (tools_factory.get_tools(
+                [
+                    adjust_response_to_student,
+                ]
+            ) +
+            tools_factory.standard_tools() + 
+            tools_factory.guardrail_tools() +
+            [query_tool]
+    )
+
+@st.cache_resource
+def initialize_agent(agent_type: AgentType, _cfg):
+    date = datetime.datetime.now().strftime("%Y-%m-%d")
+    bot_instructions = f"""
+    - You are a helpful teacher assistant, with expertise in education in various teaching styles.
+    - Today's date is {date}.
+    - Response in a concise and clear manner, and provide the most relevant information to the student.
+    - Use tools when available instead of depending on your own knowledge.
+    """
+
+    def update_func(status_type: AgentStatusType, msg: str):
+        output = f"{status_type.value} - {msg}"
+        st.session_state.thinking_placeholder.text(output)
+
+    agent = Agent(
+        agent_type=agent_type,
+        tools=create_tools(_cfg),
+        topic="An educator with expertise in philosophy",
+        custom_instructions=bot_instructions,
+        update_func=update_func
+    )
+    return agent
+
+def launch_bot(agent_type: AgentType):
     def reset():
         cfg = st.session_state.cfg
-        llm = OpenAI(model="gpt-4o", temperature=0)        
-        tr_prompt = Translator(to_lang=languages[cfg.language]).translate(initial_prompt)
-        st.session_state.messages = [{"role": "assistant", "content": tr_prompt, "avatar": "🦖"}]
-        st.session_state.thinking_prompt = Translator(to_lang=languages[cfg.language]).translate("Thinking...")
-        vectara = VectaraIndex(vectara_api_key=cfg.api_key, 
-                               vectara_customer_id=cfg.customer_id, 
-                               vectara_corpus_id=cfg.corpus_id)
-
-        # Create tool to adapt output to style, age and language
-        def adjust_response_to_student(
-                text: str = Field(descrition='the original text'), 
-                age: int = Field(description='the age of the student. An integer'), 
-                style: str = Field(description='teaching style'), 
-                language: str = Field(description='the language')
-            ) -> str:
-            """
-            Rephrase the text to match the student's age, desired teaching style and language
-            """
-            llm = OpenAI(model="gpt-4o", temperature=0)
-            prompt = f'''
-            The following is response the teacher is planning to provide to a student based on their question.
-            Please adjust the response to match the student's age of {age}, the {style} teaching style.
-            For example, in the inquiry-based teaching style, choose to ask questions that encourage the student to think critically instead of repsonding directly with the answer.
-            Or in the socratic teaching style, choose to ask questions that lead the student to the answer.
-            Always respond in the {language} language.
-            original response: {text}
-            adjusted response:
-            '''
-            response = llm.complete(prompt)
-            return response
-
-
-        # Create the Vectara Tool
-        vectara_tool = QueryEngineTool(
-            query_engine = vectara.as_query_engine(summary_enabled = True, summary_num_results = 15, summary_response_lang = languages[cfg.language],
-                                                   summary_prompt_name = "ectara-experimental-summary-ext-2023-12-11-large",
-                                                   vectara_query_mode = "mmr", rerank_k = 50, mmr_diversity_bias = 0.2,
-                                                   n_sentence_before = 5, n_sentence_after = 5),
-            metadata = ToolMetadata(name="vectara", 
-                                    description="""
-                                    A tool that is able to answer questions about the justice, morality, politics and related topics.
-                                    Based on transcripts of recordings from the Justice Harvard class that includes a lot of content on these topics.
-                                    When using the tool it's best to ask simple short questions.
-                                    """),
-        )
-
-        rephrase_tool = FunctionTool.from_defaults(adjust_response_to_student)
-
-        # Create the agent
-        prompt = prompt_template.replace("{style}", cfg.style) \
-                                .replace("{language}", cfg.language) \
-                                .replace("{student_age}", str(cfg.student_age))
-        tools = [vectara_tool, rephrase_tool]
-        if agent_type == 'react':
-            st.session_state.agent = ReActAgent.from_tools(
-                tools=tools, llm=llm, verbose=True,
-                react_chat_formatter = ReActChatFormatter(system_header=prompt),
-                max_iterations = 20,
-            )
-        elif agent_type == 'openai':
-            st.session_state.agent = OpenAIAgent.from_tools(
-                tools=tools, llm=llm, verbose=True,
-                system_prompt=prompt)
-        else:
-            raise ValueError(f"Unknown agent type: {agent_type}")        
-
+        st.session_state.messages = [{"role": "assistant", "content": initial_prompt, "avatar": "🦖"}]
+        st.session_state.thinking_message = "Agent at work..."
+        st.session_state.agent = initialize_agent(agent_type, cfg)
 
+    st.set_page_config(page_title="Justice Harvard Teaching Assistant", layout="wide")
     if 'cfg' not in st.session_state:
         cfg = OmegaConf.create({
             'customer_id': str(os.environ['VECTARA_CUSTOMER_ID']),
@@ -106,15 +115,15 @@ def launch_bot(agent_type: str):
             'style': teaching_styles[0],
             'language': 'English',
             'student_age': 18
+
         })
         st.session_state.cfg = cfg
         st.session_state.style = cfg.style
         st.session_state.language = cfg.language
         st.session_state.student_age = cfg.student_age
-        reset()
 
+        reset()
     cfg = st.session_state.cfg
-    st.set_page_config(page_title="Teaching Assistant", layout="wide")
 
     # left side content
     with st.sidebar:
@@ -168,22 +177,23 @@ def launch_bot(agent_type: str):
     if prompt := st.chat_input():
         st.session_state.messages.append({"role": "user", "content": prompt, "avatar": '🧑‍💻'})
         with st.chat_message("user", avatar='🧑‍💻'):
-            print_text(f"Starting new question: {prompt}\n", color='green')
+            print(f"Starting new question: {prompt}\n")
             st.write(prompt)
 
-    # Generate a new response if last message is not from assistant
     if st.session_state.messages[-1]["role"] != "assistant":
         with st.chat_message("assistant", avatar='🤖'):
-            with st.spinner(st.session_state.thinking_prompt):
+            with st.spinner(st.session_state.thinking_message):
+                st.session_state.thinking_placeholder = st.empty()
                 res = st.session_state.agent.chat(prompt)
-                cleaned = re.sub(r'\[\d+\]', '', res.response)
-                st.write(cleaned)
+                cleaned = re.sub(r'\[\d+\]', '', res).replace('$', '\\$')
             message = {"role": "assistant", "content": cleaned, "avatar": '🤖'}
             st.session_state.messages.append(message)
-    
+            st.session_state.thinking_placeholder.empty()
+            st.rerun()
+  
     sys.stdout.flush()
-
+    
+ 
 if __name__ == "__main__":
-    print("Starting up...")
-    launch_bot(agent_type = 'openai')
+    launch_bot(agent_type=AgentType.OPENAI)
     

prompts.py

@@ -1,76 +0,0 @@
-
-prompt_template = """
-
-You are a helpful teaching assistant in conversation with a {student_age} years old student.
-    You task is to help the student with a variety of tasks, from answering questions
-    to providing summaries to other types of analyses.
-    You specialize in the {style} teaching style and apply it to this conversation.
-
-The course you are helping the student with 
-examines fundamental questions of political philosophy and moral reasoning. 
-It challenges students to think critically about justice, equality, democracy, and citizenship 
-through the lens of classical and contemporary philosophical arguments.
-
-## Tools
-You have access to tools. You are responsible for using
-the tools in any sequence you deem appropriate to complete the task at hand.
-This may require breaking the task into subtasks and using different tools
-to complete each subtask.
-
-The tools must be your main source of information to answer the student's questions.
-If you can't answer the question with the provided tools, you must say so.
-
-You have access to the following tools:
-{tool_desc}
-
-## Input
-The user will specify a task or a question in text.
-
-## Output Format
-To answer the question, please use the following format.
-
-```
-Thought: I need to use a tool to help me answer the question.
-Action: tool name (one of {tool_names}) if using a tool.
-Action Input: the input to the tool, in a JSON format representing the kwargs (e.g. {{"input": "hello world", "num_beams": 5}})
-```
-
-Please ALWAYS start with a Thought.
-Please use a valid JSON format for the Action Input. Do NOT do this {{'input': 'hello world', 'num_beams': 5}}.
-
-If this format is used, the tool will respond in the following format:
-```
-Observation: tool response
-```
-
-You should keep repeating the above format until you have enough information
-to answer the question without using any more tools. 
-
-At that point, you MUST respond
-
-Respond in the one of the following two formats:
-
-```
-Thought: I can answer without using any more tools.
-Answer: [your answer here]
-```
-OR if you cannot answer the question with the provided tools:
-
-```
-Thought: I cannot answer the question with the provided tools.
-Answer: Sorry, I cannot answer your question.
-```
-
-ADDITIONAL INSTRUCTIONS:
-- When using a tool, break down complex questions into a set of shorter questions, and ask the tool about each of them.
-- If a tool does not respond with a clear answer or cannot answer the query properly, try to rephrase your query or break it down into sub-queries to help it respond properly.
-- You must make at least one use of a tool for each question before responding.
-- Make sure your response relies on the tools you have used and the information from those tools. 
-- Do not base your response on information that was not provided by the tools.
-- The tool response may include citations in the form [1], [2], etc. Ignore these citations.
-- Always use the rephrase tool at the end in order to ensure it fits the student's age, the desired teaching style and the language {language}
-
-## Current Conversation
-Below is the current conversation consisting of interleaving student and assistant messages.
-
-"""