Delete agent.py

agent.py

@@ -1,319 +0,0 @@
-import os
-from dotenv import load_dotenv
-from duckduckgo_search import ddg
-load_dotenv()
-
-# --- Supabase Setup (only if credentials are provided) ---
-supabase_url = os.getenv("SUPABASE_URL")
-supabase_key = os.getenv("SUPABASE_SERVICE_KEY") or os.getenv("SUPABASE_KEY")
-
-if supabase_url and supabase_key:
-    from supabase.client import Client, create_client
-    from langchain_community.vectorstores import SupabaseVectorStore
-    from langchain.tools.retriever import create_retriever_tool
-    from langchain_openai import OpenAIEmbeddings
-    supabase: Client = create_client(supabase_url, supabase_key)
-else:
-    supabase = None
-
-# --- Standard Imports ---
-from langgraph.graph import START, StateGraph, MessagesState
-from langgraph.prebuilt import tools_condition, ToolNode
-from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
-from langchain_core.tools import tool
-
-# OpenAI LLM
-from langchain_openai import ChatOpenAI
-
-# Optional document loaders
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_community.document_loaders import WikipediaLoader, ArxivLoader
-
-# --- Simple Math Tools ---
-@tool
-def multiply(a: int, b: int) -> int:
-    """Multiply two integers and return the result"""
-    return a * b
-
-@tool
-def add(a: int, b: int) -> int:
-    """Add two integers and return the sum"""
-    return a + b
-
-@tool
-def subtract(a: int, b: int) -> int:
-    """Subtract the second integer from the first and return the difference"""
-    return a - b
-
-@tool
-def divide(a: int, b: int) -> float:
-    """Divide the first integer by the second and return the quotient"""
-    if b == 0:
-        raise ValueError("Cannot divide by zero.")
-    return a / b
-
-@tool
-def modulus(a: int, b: int) -> int:
-    """Return the modulus of dividing the first integer by the second"""
-    return a % b
-
-# --- Search Tools ---
-@tool
-def wiki_search(query: str) -> str:
-    """Search Wikipedia for the query and return up to 2 documents"""
-    try:
-        docs = WikipediaLoader(query=query, load_max_docs=2).load()
-        return "\n\n---\n\n".join(
-            f'<Document source="{doc.metadata["source"]}"/>\n{doc.page_content}' for doc in docs
-        )
-    except Exception as e:
-        return f"Wikipedia search failed: {str(e)}"
-
-@tool
-def web_search(query: str) -> str:
-    """
-    Search DuckDuckGo via the DDGS class and return the top 3 results
-    (title, URL, and snippet).
-    """
-    try:
-        with DDGS() as ddgs:
-            results = ddgs.text(query, max_results=3)
-    except Exception as e:
-        return f"DuckDuckGo search error: {e}"
-
-    if not results:
-        return "No results from DuckDuckGo."
-
-    formatted = []
-    for r in results:
-        title = r.get("title", "<no title>").strip()
-        url   = r.get("href", "<no URL>").strip()
-        body  = r.get("body", "").strip()
-        formatted.append(f"• **{title}**\n  {url}\n  _{body}_")
-    return "\n\n".join(formatted)
-# def web_search(query: str) -> str:
-#     """Search the web using Tavily and return up to 3 results"""
-#     try:
-#         tavily_api_key = os.getenv("TAVILY_API_KEY")
-#         if not tavily_api_key:
-#             return "Web search unavailable: TAVILY_API_KEY not configured"
-        
-#         search_tool = TavilySearchResults(max_results=3, api_key=tavily_api_key)
-#         docs = search_tool.invoke({"query": query})
-#         return "\n\n---\n\n".join(
-#             f'<Document source="{doc.get("url", "Unknown")}"/>\n{doc.get("content", "")}' for doc in docs
-#         )
-#     except Exception as e:
-#         return f"Web search failed: {str(e)}"
-
-@tool
-def arxiv_search(query: str) -> str:
-    """Search Arxiv for the query and return up to 3 documents"""
-    try:
-        docs = ArxivLoader(query=query, load_max_docs=3).load()
-        return "\n\n---\n\n".join(
-            f'<Document source="{doc.metadata["source"]}"/>\n{doc.page_content[:1000]}' for doc in docs
-        )
-    except Exception as e:
-        return f"Arxiv search failed: {str(e)}"
-
-# --- Assemble Tools List ---
-tools = [multiply, add, subtract, divide, modulus, wiki_search, web_search, arxiv_search]
-
-# If supabase is configured, add retriever tool
-if supabase:
-    try:
-        embeddings = OpenAIEmbeddings()
-        vector_store = SupabaseVectorStore(
-            client=supabase,
-            embedding=embeddings,
-            table_name="documents",
-            query_name="match_documents_langchain",
-        )
-        retriever_tool = create_retriever_tool(
-            retriever=vector_store.as_retriever(),
-            name="Question Search",
-            description="Retrieve similar questions from the vector store",
-        )
-        tools.append(retriever_tool)
-    except Exception as e:
-        print(f"Could not initialize Supabase retriever: {e}")
-
-# --- Load System Prompt ---
-def load_system_prompt():
-    """Load system prompt with fallback"""
-    try:
-        with open("system_prompt.txt", "r", encoding="utf-8") as f:
-            return SystemMessage(content=f.read())
-    except FileNotFoundError:
-        # Fallback system prompt
-        default_prompt = """You are a helpful AI assistant with access to various tools including:
-- Math operations (add, subtract, multiply, divide, modulus)
-- Search capabilities (Wikipedia, Arxiv, web search via Tavily)
-- Information retrieval
-
-Use these tools when appropriate to answer questions accurately and helpfully. When performing calculations, always use the provided math tools. When users ask for information that might require current data or research, use the appropriate search tools.
-
-Be concise but thorough in your responses. If you use a tool, explain what you found or calculated."""
-        return SystemMessage(content=default_prompt)
-
-sys_msg = load_system_prompt()
-
-# --- Graph Builder (OpenAI) ---
-def build_graph():
-    """
-    Build and return a StateGraph using OpenAI ChatGPT with tools.
-    """
-    print("=== BUILDING OPENAI GRAPH ===")
-    
-    # Check for OpenAI API key
-    openai_api_key = os.getenv("OPENAI_API_KEY")
-    print(f"OpenAI API Key: {'Found' if openai_api_key else 'Not found'}")
-    
-    if openai_api_key:
-        print(f"API Key starts with: {openai_api_key[:10]}...")
-    
-    try:
-        if openai_api_key and len(openai_api_key.strip()) > 0:
-            print("Attempting to initialize OpenAI ChatGPT...")
-            
-            # Initialize OpenAI LLM
-            llm = ChatOpenAI(
-                model="gpt-4",  # You can change to "gpt-4" if you have access
-                temperature=0.1,
-                api_key=openai_api_key.strip(),
-                max_tokens=512
-            )
-            
-            # Test the connection
-            test_response = llm.invoke([HumanMessage(content="Hello")])
-            print("✓ Successfully connected to OpenAI")
-            print(f"Test response: {test_response.content[:50]}...")
-            
-        else:
-            raise Exception("No valid OPENAI_API_KEY found")
-        
-    except Exception as e:
-        print(f"Error initializing OpenAI LLM: {e}")
-        print("Creating functional mock LLM...")
-        
-        class FunctionalMockLLM:
-            def bind_tools(self, tools):
-                self.tools = tools
-                return self
-                
-            def invoke(self, messages):
-                from langchain_core.messages import AIMessage
-                import json
-                import re
-                
-                last_msg = messages[-1] if messages else None
-                if not last_msg:
-                    return AIMessage(content="Please ask me a question!")
-                
-                content = getattr(last_msg, 'content', str(last_msg))
-                content_lower = content.lower()
-                
-                # Handle math operations with tool calls
-                math_patterns = [
-                    (r'(\d+)\s*\+\s*(\d+)', 'add'),
-                    (r'(\d+)\s*-\s*(\d+)', 'subtract'),
-                    (r'(\d+)\s*\*\s*(\d+)', 'multiply'),
-                    (r'(\d+)\s*/\s*(\d+)', 'divide'),
-                    (r'(\d+)\s*%\s*(\d+)', 'modulus'),
-                ]
-                
-                for pattern, operation in math_patterns:
-                    match = re.search(pattern, content)
-                    if match:
-                        a, b = int(match.group(1)), int(match.group(2))
-                        
-                        tool_call = {
-                            "name": operation,
-                            "args": {"a": a, "b": b},
-                            "id": f"call_{operation}_{a}_{b}"
-                        }
-                        
-                        return AIMessage(
-                            content=f"I'll {operation} {a} and {b} for you.",
-                            tool_calls=[tool_call]
-                        )
-                
-                # Handle search requests
-                if any(word in content_lower for word in ['search', 'find', 'look up', 'what is', 'who is', 'tell me about']):
-                    # Extract search query
-                    search_query = content
-                    for phrase in ['search for', 'find', 'look up', 'what is', 'who is', 'tell me about']:
-                        search_query = search_query.lower().replace(phrase, '').strip()
-                    
-                    if len(search_query) > 100:
-                        search_query = search_query[:100]
-                    
-                    if 'wikipedia' in content_lower:
-                        tool_name = "wiki_search"
-                    elif 'arxiv' in content_lower or 'research' in content_lower or 'paper' in content_lower:
-                        tool_name = "arxiv_search"
-                    else:
-                        tool_name = "web_search"
-                    
-                    tool_call = {
-                        "name": tool_name,
-                        "args": {"query": search_query},
-                        "id": f"call_{tool_name}_{hash(search_query) % 1000}"
-                    }
-                    
-                    return AIMessage(
-                        content=f"I'll search for information about: {search_query}",
-                        tool_calls=[tool_call]
-                    )
-                
-                # Default response for other questions
-                return AIMessage(content=f"I understand you're asking: {content[:200]}... I can help with math calculations and information searches. Please configure OPENAI_API_KEY for full functionality, or try asking me to calculate something or search for information.")
-        
-        llm = FunctionalMockLLM()
-        print("✓ Using functional mock LLM")
-    
-    # Bind tools to LLM
-    llm_with_tools = llm.bind_tools(tools)
-
-    def retriever(state: MessagesState):
-        """Add system message and handle retrieval if Supabase is available"""
-        messages = [sys_msg] + state["messages"]
-        
-        if supabase and len(tools) > 8:  # Check if retriever tool was added
-            try:
-                query = state["messages"][-1].content
-                docs = vector_store.similarity_search(query, k=1)
-                if docs:
-                    doc = docs[0]
-                    content = doc.page_content
-                    answer = content.split("Final answer :")[-1].strip() if "Final answer :" in content else content.strip()
-                    return {"messages": messages + [AIMessage(content=f"Retrieved context: {answer}")]}
-            except Exception as e:
-                print(f"Retrieval error: {e}")
-        
-        return {"messages": messages}
-
-    def assistant(state: MessagesState):
-        """Main assistant function"""
-        try:
-            response = llm_with_tools.invoke(state["messages"])
-            return {"messages": [response]}
-        except Exception as e:
-            print(f"Assistant error: {e}")
-            return {"messages": [AIMessage(content=f"I encountered an error: {str(e)}. Please make sure your OPENAI_API_KEY is configured correctly.")]}
-
-    # Build the graph
-    g = StateGraph(MessagesState)
-    g.add_node("retriever", retriever)
-    g.add_node("assistant", assistant)
-    g.add_node("tools", ToolNode(tools))
-    
-    # Define edges
-    g.add_edge(START, "retriever")
-    g.add_edge("retriever", "assistant")
-    g.add_conditional_edges("assistant", tools_condition)
-    g.add_edge("tools", "assistant")
-    
-    print("✓ Graph compiled successfully")
-    return g.compile()