Update agent.py

agent.py

@@ -1,62 +1,64 @@
-"""LangGraph Agent – Solo GPT-4.1 (OpenAI) con docstring obbligatorie."""
+"""LangGraph Agent – versione senza Supabase"""
 
 import os
 from dotenv import load_dotenv
 from langgraph.graph import START, StateGraph, MessagesState
 from langgraph.prebuilt import ToolNode, tools_condition
-from langchain_openai import ChatOpenAI
-from langchain_core.messages import SystemMessage, HumanMessage
-from langchain_core.tools import tool
 
-# Loader & search tools
+# LLM providers
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
+from langchain_huggingface import (
+    ChatHuggingFace,
+    HuggingFaceEndpoint,
+)
+
+# Tools & loaders
 from langchain_community.tools.tavily_search import TavilySearchResults
 from langchain_community.document_loaders import WikipediaLoader, ArxivLoader
+from langchain_core.messages import SystemMessage, HumanMessage
+from langchain_core.tools import tool
 
-# ------------------------------------------------------------------ #
-#  Ambiente                                                          #
-# ------------------------------------------------------------------ #
-load_dotenv()  # carica OPENAI_KEY dallo Space
-OPENAI_KEY = os.getenv("OPENAI_KEY")
-if not OPENAI_KEY:
-    raise ValueError("❌  OPENAI_KEY non impostata: aggiungila nei Secrets dello Space.")
-
-# ------------------------------------------------------------------ #
-#  TOOL: aritmetica                                                  #
-# ------------------------------------------------------------------ #
+load_dotenv()  # carica eventuali variabili dal file .env
+
+# --------------------------------------------------------------------------- #
+#  TOOL: operazioni aritmetiche                                               #
+# --------------------------------------------------------------------------- #
 @tool
 def multiply(a: int, b: int) -> int:
     """Multiply two integers and return the product."""
     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.
-
-    Raises:
-        ValueError: If b is zero.
-    """
+    """Divide a by b and return the quotient (error if b == 0)."""
     if b == 0:
         raise ValueError("Cannot divide by zero.")
     return a / b
 
+
 @tool
 def modulus(a: int, b: int) -> int:
     """Return the remainder of the division of a by b."""
     return a % b
 
-# ------------------------------------------------------------------ #
-#  TOOL: Wikipedia                                                   #
-# ------------------------------------------------------------------ #
+
+# --------------------------------------------------------------------------- #
+#  TOOL: Wikipedia                                                            #
+# --------------------------------------------------------------------------- #
 @tool
 def wiki_search(query: str) -> str:
     """Search Wikipedia (max 2 docs) and return formatted content."""
@@ -67,12 +69,13 @@ def wiki_search(query: str) -> str:
         for d in docs
     )
 
-# ------------------------------------------------------------------ #
-#  TOOL: Tavily web search                                           #
-# ------------------------------------------------------------------ #
+
+# --------------------------------------------------------------------------- #
+#  TOOL: Tavily web search                                                    #
+# --------------------------------------------------------------------------- #
 @tool
 def web_search(query: str) -> str:
-    """Perform a web search using Tavily (max 3 docs) and return formatted content."""
+    """Perform a web search with Tavily (max 3 docs) and return formatted content."""
     docs = TavilySearchResults(max_results=3).invoke(query=query)
     return "\n\n---\n\n".join(
         f'<Document source="{d.metadata["source"]}" page="{d.metadata.get("page","")}"/>\n'
@@ -80,12 +83,13 @@ def web_search(query: str) -> str:
         for d in docs
     )
 
-# ------------------------------------------------------------------ #
-#  TOOL: ArXiv                                                       #
-# ------------------------------------------------------------------ #
+
+# --------------------------------------------------------------------------- #
+#  TOOL: ArXiv                                                                #
+# --------------------------------------------------------------------------- #
 @tool
 def arxiv_search(query: str) -> str:
-    """Search ArXiv (max 3 docs) and return the first 1000 chars of each paper."""
+    """Search ArXiv (max 3 docs) and return first 1000 characters per paper."""
     docs = ArxivLoader(query=query, load_max_docs=3).load()
     return "\n\n---\n\n".join(
         f'<Document source="{d.metadata["source"]}" page="{d.metadata.get("page","")}"/>\n'
@@ -93,62 +97,75 @@ def arxiv_search(query: str) -> str:
         for d in docs
     )
 
-# ------------------------------------------------------------------ #
-#  System prompt                                                     #
-# ------------------------------------------------------------------ #
+
+# --------------------------------------------------------------------------- #
+#  System prompt                                                              #
+# --------------------------------------------------------------------------- #
 with open("system_prompt.txt", "r", encoding="utf-8") as f:
     system_prompt = f.read()
 sys_msg = SystemMessage(content=system_prompt)
 
-# ------------------------------------------------------------------ #
-#  Tool list                                                         #
-# ------------------------------------------------------------------ #
+# --------------------------------------------------------------------------- #
+#  Lista tool                                                                 #
+# --------------------------------------------------------------------------- #
 tools = [
-    multiply, add, subtract, divide, modulus,
-    wiki_search, web_search, arxiv_search,
+    multiply,
+    add,
+    subtract,
+    divide,
+    modulus,
+    wiki_search,
+    web_search,
+    arxiv_search,
 ]
 
-# ------------------------------------------------------------------ #
-#  Build LangGraph                                                   #
-# ------------------------------------------------------------------ #
-def build_graph():
-    """Return a LangGraph graph that uses only GPT-4.1 via OpenAI."""
-    llm = ChatOpenAI(
-        model_name="gpt-4.1",
-        temperature=0,
-        openai_api_key=OPENAI_KEY,
-    )
-    llm_with_tools = llm.bind_tools(tools)
+# --------------------------------------------------------------------------- #
+#  Build LangGraph                                                            #
+# --------------------------------------------------------------------------- #
+def build_graph(provider: str = "groq"):
+    """Return a LangGraph graph without Supabase dependencies."""
+    # ------------ LLM selection ------------------------------------------- #
+    if provider == "google":
+        llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
+    elif provider == "groq":
+        llm = ChatGroq(model="qwen-qwq-32b", temperature=0)
+    elif provider == "huggingface":
+        llm = ChatHuggingFace(
+            llm=HuggingFaceEndpoint(
+                url="https://api-inference.huggingface.co/models/Meta-DeepLearning/llama-2-7b-chat-hf",
+                temperature=0,
+            )
+        )
+    else:
+        raise ValueError("Invalid provider. Choose 'google', 'groq' or 'huggingface'.")
 
-    # Nodes --------------------------------------------------------- #
-    def prepend_system(state: MessagesState):
-        """Prepend system prompt to the incoming messages."""
-        return {"messages": [sys_msg] + state["messages"]}
+    llm_with_tools = llm.bind_tools(tools)
 
+    # ------------------ Nodes -------------------------------------------- #
     def assistant(state: MessagesState):
-        """Invoke the LLM (tool calling enabled)."""
-        return {"messages": [llm_with_tools.invoke(state["messages"])]}
+        """Invoke LLM with system prompt prepended."""
+        messages = [sys_msg] + state["messages"]
+        return {"messages": [llm_with_tools.invoke(messages)]}
 
-    # Graph --------------------------------------------------------- #
+    # ------------------ Graph -------------------------------------------- #
     builder = StateGraph(MessagesState)
-    builder.add_node("system", prepend_system)
     builder.add_node("assistant", assistant)
     builder.add_node("tools", ToolNode(tools))
 
-    builder.add_edge(START, "system")
-    builder.add_edge("system", "assistant")
+    builder.add_edge(START, "assistant")
     builder.add_conditional_edges("assistant", tools_condition)
     builder.add_edge("tools", "assistant")
 
     return builder.compile()
 
-# ------------------------------------------------------------------ #
-#  Test rapido                                                       #
-# ------------------------------------------------------------------ #
+
+# --------------------------------------------------------------------------- #
+#  Test rapido                                                                #
+# --------------------------------------------------------------------------- #
 if __name__ == "__main__":
-    g = build_graph()
-    query = "When was a picture of St. Thomas Aquinas first added to the Wikipedia page on the Principle of double effect?"
-    msgs = [HumanMessage(content=query)]
-    result = g.invoke({"messages": msgs})
+    graph = build_graph(provider="groq")
+    question = "When was a picture of St. Thomas Aquinas first added to the Wikipedia page on the Principle of double effect?"
+    messages = [HumanMessage(content=question)]
+    result = graph.invoke({"messages": messages})
     for m in result["messages"]:
         m.pretty_print()