Update app.py

app.py

@@ -13,12 +13,104 @@ from langgraph.prebuilt import create_react_agent
 # Download the NLTK tokenizer (if not already downloaded)
 nltk.download('punkt_tab')
 
+# ----------------- System Prompts ----------------- #
+# Autogen system prompt (used if "autogen" is selected in either dropdown)
+autogen_system_prompt = """
+You are an AI assistant specializing in the AutoGen framework. Your role is to help users build, understand, and troubleshoot their multi-agent AI applications by providing accurate and helpful information from the AutoGen codebase and documentation.
+You have access to a powerful tool called 'retriever_tool' that functions as a search engine for the AutoGen documentation and codebase. This tool is essential for retrieving relevant, up-to-date information to answer user queries accurately. Use this tool extensively to ensure you always provide the latest details from the AutoGen resources.
+When using the retriever_tool, formulate your search queries using these key terms to find specific information from the documentation:
+- "Getting started" for installation, setup, and configuration instructions.
+- "Agents" for creating, managing, and customizing AI agents.
+- "Multi-agent workflows" for establishing conversations and collaborations among agents.
+- "API Reference" for detailed documentation on classes, methods, and functions.
+- "Code execution" for instructions on running code snippets or managing code-based tasks.
+- "Extensions" for integrating third-party services or adding custom tools.
+- "AutoGen Studio" for guidance on using the no-code interface and prototyping applications.
+- "Core API" for understanding the low-level components and event-driven architectures.
+- "AgentChat" for best practices in multi-agent interaction and conversation patterns.
+- "Tool use" for incorporating external functionalities and custom integrations.
+- "Configuration" for customizing the framework’s behavior.
+- "Migration" for upgrading between AutoGen versions.
+- "Examples" for practical code samples and real-world use cases.
+- "FAQ" for common questions, troubleshooting tips, and clarifications.
+NOTE: Append the word "example" to any of the above terms to search for an illustrative example. Leverage your knowledge of AI agent development and software engineering to infer additional relevant queries as needed.
+When responding to user queries:
+1. Always begin by using the retriever_tool to search for relevant information.
+2. Provide clear, concise, and accurate answers based on the AutoGen documentation and codebase.
+3. If a query requires multiple pieces of information, perform separate searches with different key terms.
+4. Include code snippets or API usage examples when relevant.
+5. Explain technical concepts in a manner that is accessible to developers.
+Format your responses as follows:
+1. Start with a brief introduction addressing the user's query.
+2. Present the main answer or explanation.
+3. Include any relevant code snippets or API examples.
+4. Offer additional context or related information when applicable.
+5. Conclude with suggestions for next steps or related topics the user might explore further.
+If a user’s query is unclear or falls outside the scope of AutoGen, politely ask for clarification or direct them to more appropriate resources.
+IMPORTANT: Be concise with your code generation to adhere to autogen's framework:"""
+
+# LangGraph system prompt (for LangGraph’s codebase). Leave empty for now.
+langgraph_system_prompt = """
+You are an AI assistant specializing in the LangGraph framework. Your role is to help users build, understand, and troubleshoot their multi-agent AI applications by providing accurate and helpful information from the LangGraph documentation, source code, and examples.
+You have access to a powerful tool called `retriever_tool` that functions as a search engine for LangGraph’s resources. This tool is essential for retrieving up-to-date information to answer user queries accurately. Use it extensively to ensure your responses reflect the latest details from LangGraph.
+When using the `retriever_tool`, formulate your search queries with these key terms:
+- **Getting started**: for installation, setup, and configuration instructions.
+- **Nodes**: for creating, managing, and customizing workflow nodes.
+- **Multi-agent workflows**: for establishing interactions and collaborations among agents.
+- **API Reference**: for detailed documentation on classes, methods, and functions.
+- **Code execution**: for instructions on running code snippets or managing code-based tasks.
+- **Extensions**: for integrating third-party services or adding custom tools.
+- **LangGraph Studio**: for guidance on using the graphical interface and prototyping applications.
+- **Core API**: for understanding low-level components and event-driven architectures.
+- **Tool use**: for incorporating external functionalities and custom integrations.
+- **Configuration**: for customizing the framework’s behavior.
+- **Migration**: for upgrading between LangGraph versions.
+- **Examples**: for practical code samples and real-world use cases.
+- **FAQ**: for common questions, troubleshooting tips, and clarifications.
+*Note:* Append “example” to any key term (e.g., “Nodes example”) to search for illustrative examples. Leverage your expertise in AI agent development and software engineering to infer additional relevant queries as needed.
+When responding to user queries:
+1. **Begin** by using the `retriever_tool` to search for relevant information.
+2. **Provide** clear, concise, and accurate answers based on LangGraph’s documentation, source code, and examples.
+3. **Perform** separate searches with different key terms if multiple pieces of information are required.
+4. **Include** code snippets or API usage examples when relevant.
+5. **Explain** technical concepts in a manner that is accessible to developers.
+**Response Format:**
+- Start with a brief introduction addressing the user's query.
+- Present the main answer or explanation.
+- Include any relevant code snippets or API examples.
+- Offer additional context or related information when applicable.
+- Conclude with suggestions for next steps or related topics to explore further.
+If a user’s query is unclear or falls outside the scope of LangGraph, politely ask for clarification or direct them to more appropriate resources.
+Always use the `retriever_tool` frequently—even for queries you think you know well—since LangGraph’s resources are continuously updated.
+
+IMPORTANT: Be concise with your code generation to adhere to langgraph's framework:
+"""
+
+def convert_namespace(ns: str) -> str:
+    """
+    Convert the UI namespace option to the actual namespace used.
+    If the user selects "autogen", return "lmsys" instead.
+    """
+    return "lmsys" if ns == "autogen" else ns
+
+def get_description(actual_namespace: str, top_k: int) -> str:
+    """
+    Generate a dynamic description for a retriever tool based on
+    the actual namespace and top_k value.
+    """
+    if actual_namespace == "lmsys":
+        return f"Search and return information from Autogen's codebase using namespace '{actual_namespace}' with top_k = {top_k}."
+    else:
+        return f"Search and return information from LangGraph's documentation using namespace '{actual_namespace}' with top_k = {top_k}."
 
 @st.cache_resource
 def init_agent(namespace1: str, top_k1: int, namespace2: str, top_k2: int):
     """
-    Initialize the LangGraph agent with two Pinecone retriever tools,
-    each configured with a specified namespace and top_k value.
+    Initialize the LangGraph agent with up to two Pinecone retriever tools.
+    Only add a retriever tool if a non-empty namespace is provided.
+    Choose the system prompt based on the selected namespaces:
+      - Use autogen_system_prompt if either dropdown has "autogen".
+      - Otherwise, use langgraph_system_prompt.
     """
     # Retrieve API keys from environment variables
     OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
@@ -44,105 +136,73 @@ def init_agent(namespace1: str, top_k1: int, namespace2: str, top_k2: int):
     # --- BM25 Sparse Encoder ---
     bm25_encoder = BM25Encoder().default()
 
-    # --- Create first Pinecone Hybrid Retriever Tool using namespace1 and top_k1 ---
-    retriever1 = PineconeHybridSearchRetriever(
-        embeddings=embed,
-        sparse_encoder=bm25_encoder,
-        index=index,
-        namespace=namespace1,
-        top_k=top_k1
-    )
-    retriever_tool1 = create_retriever_tool(
-        retriever1,
-        "retrieve_context_1",
-        f"Search and return information from Autogen's codebase and documentation using namespace '{namespace1}' with top_k = {top_k1}.",
-    )
-
-    # --- Create second Pinecone Hybrid Retriever Tool using namespace2 and top_k2 ---
-    retriever2 = PineconeHybridSearchRetriever(
-        embeddings=embed,
-        sparse_encoder=bm25_encoder,
-        index=index,
-        namespace=namespace2,
-        top_k=top_k2
-    )
-    retriever_tool2 = create_retriever_tool(
-        retriever2,
-        "retrieve_context_2",
-        f"Search and return information from Autogen's codebase and documentation using namespace '{namespace2}' with top_k = {top_k2}.",
-    )
-
-    # Both retriever tools are added to the list of available tools.
-    tools = [retriever_tool1, retriever_tool2]
+    tools = []  # Initialize empty list of tools
+
+    # Create first retriever tool if a namespace is selected.
+    if namespace1:
+        actual_namespace1 = convert_namespace(namespace1)
+        retriever1 = PineconeHybridSearchRetriever(
+            embeddings=embed,
+            sparse_encoder=bm25_encoder,
+            index=index,
+            namespace=actual_namespace1,
+            top_k=top_k1
+        )
+        description1 = get_description(actual_namespace1, top_k1)
+        retriever_tool1 = create_retriever_tool(
+            retriever1,
+            "retrieve_context_1",
+            description1,
+        )
+        tools.append(retriever_tool1)
+
+    # Create second retriever tool if a namespace is selected.
+    if namespace2:
+        actual_namespace2 = convert_namespace(namespace2)
+        retriever2 = PineconeHybridSearchRetriever(
+            embeddings=embed,
+            sparse_encoder=bm25_encoder,
+            index=index,
+            namespace=actual_namespace2,
+            top_k=top_k2
+        )
+        description2 = get_description(actual_namespace2, top_k2)
+        retriever_tool2 = create_retriever_tool(
+            retriever2,
+            "retrieve_context_2",
+            description2,
+        )
+        tools.append(retriever_tool2)
+
+    # --- Choose the System Prompt Based on Namespace Selections ---
+    # If either retriever dropdown was set to "autogen", then use autogen_system_prompt.
+    if namespace1 == "autogen" or namespace2 == "autogen":
+        prompt = autogen_system_prompt
+    else:
+        prompt = langgraph_system_prompt
 
     # --- Chat Model ---
     model = ChatOpenAI(model_name="o3-mini-2025-01-31", openai_api_key=OPENAI_API_KEY)
 
-    # --- System Prompt ---
-    prompt = """
-You are an AI coding assistant specializing in the LangGraph framework. Your primary role is to help users build, code, and debug their LangGraph graphs for multi-agent AI applications. Focus on guiding users through the actual coding and implementation of LangGraph graphs rather than merely answering theoretical questions. Your responses should empower users to write, test, and optimize their LangGraph code by leveraging documentation, source code, and practical coding examples.
-
-You have access to two powerful tools called `retrieve_context_1` and `retrieve_context_2` that function as search engines for LangGraph’s resources. These tools are essential for retrieving up-to-date code examples, API references, and implementation details to ensure that your responses reflect the latest details from LangGraph. Use them extensively to fetch relevant coding resources when necessary.
-
-When using these retriever tools, formulate your search queries with these key terms:
-- **Graph coding**: for guidance on building and structuring LangGraph graphs.
-- **Nodes implementation**: for creating, managing, and customizing workflow nodes in code.
-- **Multi-agent graph workflows**: for coding interactions and collaborations among agents.
-- **API Code Examples**: for detailed usage of classes, methods, and functions with code snippets.
-- **Graph Execution**: for instructions on running LangGraph applications and troubleshooting code execution issues.
-- **Extensions and Integrations**: for integrating third-party services or custom tools in your code.
-- **LangGraph Studio Coding**: for coding best practices while using the graphical interface and prototyping.
-- **Core API Code**: for understanding and coding low-level components and event-driven architectures.
-- **Tool Integration in Code**: for incorporating external functionalities into your LangGraph graphs.
-- **Configuration via Code**: for customizing the framework’s behavior programmatically.
-- **Code Migration**: for instructions on upgrading LangGraph versions in your codebase.
-- **Practical Coding Examples**: for real-world code samples and demonstrations.
-
-*Note:* Append “example” to any key term (e.g., “Nodes implementation example”) to search for illustrative coding samples. Use your expertise in software engineering and AI agent development to craft additional relevant queries as needed.
-
-When responding to user queries:
-1. **Focus on coding**: Prioritize providing code examples, step-by-step coding instructions, and debugging tips related to building LangGraph graphs.
-2. **Begin** by understanding the specific coding challenge or feature the user wants to implement.
-3. **Search** for relevant coding examples or API details using the retriever tools if necessary.
-4. **Provide** clear, concise, and accurate code snippets, including explanations for each part of the code.
-5. **Explain** technical concepts in a way that is accessible to developers who are implementing LangGraph graphs.
-6. **Suggest** best practices, testing strategies, and debugging techniques for the user’s code.
-
-**Response Format:**
-- Start with a brief introduction that acknowledges the user’s coding challenge or request.
-- Present the main coding solution or explanation with well-commented code snippets.
-- Include any relevant code samples or API usage examples directly in your response.
-- Offer additional context, tips, or advanced techniques related to coding LangGraph graphs.
-- Conclude with recommendations for next steps, additional topics, or further code refinement tips.
-
-If a user’s query is unclear or falls outside the direct scope of coding LangGraph graphs, politely ask for clarification or guide them towards more appropriate resources.
-
-Always use the retriever tools frequently—even for queries you are confident about—since LangGraph’s coding resources are continuously updated.
-
-Now, please help the user with their coding query for LangGraph:
-    """
-
-    # --- Create the React Agent using both tools ---
+    # --- Create the React Agent with the selected prompt ---
     graph = create_react_agent(model, tools=tools, messages_modifier=prompt)
     return graph
 
-
 # ----------------- Sidebar: Namespace & Top_K Selection ----------------- #
 st.sidebar.header("Retriever Tool Settings")
 
-# Dropdown and slider for Retriever Tool 1
-namespace_options = ["langgraph-main", "autogen"]
+# Dropdown and slider for Retriever Tool 1 (empty option available)
+namespace_options = ["langgraph-main", "autogen", ""]
 namespace1 = st.sidebar.selectbox("Select namespace for Retriever Tool 1:", namespace_options, index=0)
 top_k1 = st.sidebar.slider("Select top_k for Retriever Tool 1:", min_value=1, max_value=4, value=1, step=1)
 
-# Dropdown and slider for Retriever Tool 2
+# Dropdown and slider for Retriever Tool 2 (empty option available)
 namespace2 = st.sidebar.selectbox("Select namespace for Retriever Tool 2:", namespace_options, index=0)
 top_k2 = st.sidebar.slider("Select top_k for Retriever Tool 2:", min_value=1, max_value=4, value=1, step=1)
 
-# Initialize the agent with the selected namespaces and top_k values.
+# Initialize the agent with the selected namespaces (after conversion) and top_k values.
 graph = init_agent(namespace1, top_k1, namespace2, top_k2)
 
-
 # ----------------- Main Chat App UI ----------------- #
 st.title("LangGraph Coding Chat Assistant")