Simplified langgraph package.

.env

@@ -0,0 +1 @@
+SPACE_ID=

app.py

@@ -1,7 +1,6 @@
 import os
 import gradio as gr
 import requests
-import inspect
 from typing import Optional, Any
 import pandas as pd
 from init_agent import build_workflow
@@ -14,22 +13,18 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
+    """A langgraph agent."""
     workflow: Optional[Any]
     def __init__(self):
         print("BasicAgent initialized.")
         self.workflow = build_workflow()
+
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        # fixed_answer = "This is a default answer."
-        # print(f"Agent returning fixed answer: {fixed_answer}")
-        workflow_response = self.workflow.invoke({
-            "messages": [
-                HumanMessage(content="What does this code do?: var a = 10; var b = 20;")
-            ],
-            "classification": "not coding",
-            "ai_agent": None
-        })
-        return workflow_response["messages"][-1].content
+        messages = [HumanMessage(content=question)]
+        result = self.workflow.invoke({"messages": messages})
+        answer = result['messages'][-1].content
+        return answer  # kein [14:] mehr nötig!
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """

init_agent.py

@@ -1,134 +1,148 @@
 import os
 from transformers import pipeline
-from huggingface_hub import login
 from typing import Annotated, TypedDict, Optional, Any
+
 from langgraph.graph import StateGraph, START, END
 from langgraph.graph.message import add_messages
-from langchain_huggingface import HuggingFaceEndpoint, ChatHuggingFace
 
-from langchain_core.messages import AnyMessage, HumanMessage
+from langchain_huggingface import HuggingFaceEndpoint, ChatHuggingFace
+from langchain_core.messages import AnyMessage
 from langchain_community.tools import DuckDuckGoSearchRun
-
 from langchain_core.tools import Tool
 
-hf_token = os.environ.get('HF_TOKEN')
-if hf_token:
-    login(token=hf_token) 
-
-def init_classifier():
-  classifier = pipeline("zero-shot-classification", model='cross-encoder/nli-distilroberta-base')
-  return classifier
+hf_token = os.environ.get("HF_TOKEN")
 
 
-class CurrentAgent():
-  current_llm: HuggingFaceEndpoint
-  current_chat: ChatHuggingFace
-  def __init__(self):
-    self.current_llm = HuggingFaceEndpoint(
-        repo_id="Qwen/Qwen3-VL-8B-Instruct",
-        huggingfacehub_api_token=hf_token
+# -----------------------------
+# CLASSIFIER
+# -----------------------------
+def init_classifier():
+    return pipeline(
+        "zero-shot-classification",
+        model="cross-encoder/nli-distilroberta-base"
     )
-    self.current_chat = ChatHuggingFace(llm=self.current_llm, verbose=True, tools=[DuckDuckGoSearchRun()])
 
-  def update_llm(self, model_id: str, hf_token):
-    self.current_llm = HuggingFaceEndpoint(
-        repo_id=model_id,
+
+# -----------------------------
+# CODE LLM TOOL
+# -----------------------------
+def run_code_llm(prompt: str) -> str:
+    """Call the coder model directly as a tool."""
+    coder = HuggingFaceEndpoint(
+        repo_id="Qwen/Qwen2.5-Coder-32B-Instruct",
         huggingfacehub_api_token=hf_token
     )
-    self.current_chat = ChatHuggingFace(llm=self.current_llm, verbose=True, tools=[DuckDuckGoSearchRun()])
-
-
-# Define a custom agent state:
+    chat = ChatHuggingFace(llm=coder, verbose=True)
+    result = chat.invoke([{"role": "user", "content": prompt}])
+    return result.content
+
+
+code_llm_tool = Tool(
+    name="code_llm",
+    description="Use this tool to answer coding or programming questions.",
+    func=run_code_llm
+)
+
+
+# -----------------------------
+# AGENT WRAPPER
+# -----------------------------
+class CurrentAgent:
+    def __init__(self):
+        self.current_llm = HuggingFaceEndpoint(
+            repo_id="Qwen/Qwen3-VL-8B-Instruct",
+            huggingfacehub_api_token=hf_token
+        )
+        self.current_chat = ChatHuggingFace(
+            llm=self.current_llm,
+            verbose=True,
+            tools=[DuckDuckGoSearchRun(), code_llm_tool]
+        )
+
+
+# -----------------------------
+# STATE
+# -----------------------------
 class AgentState(TypedDict):
-  ai_agent:  Optional[CurrentAgent]
-  classification: str
-  messages: Annotated[list[AnyMessage], add_messages]
-
-
-tools = [DuckDuckGoSearchRun()]
+    ai_agent: Optional[CurrentAgent]
+    classification: str
+    messages: Annotated[list[AnyMessage], add_messages]
 
 
+# -----------------------------
+# CLASSIFICATION NODE
+# -----------------------------
 def classify(state: AgentState) -> AgentState:
-  classifier = init_classifier()
-  message_to_send = state['messages'][-1].content
-  candidate_labels = ["coding", "not coding"]
-  classifier_res = classifier(message_to_send, candidate_labels)
-  highest_score_label = classifier_res['labels'][0]
-  highest_score = classifier_res['scores'][0]
+    classifier = init_classifier()
+    message = state["messages"][-1].content
+
+    result = classifier(message, ["coding", "not coding"])
+    label = result["labels"][0]
+    score = result["scores"][0]
 
-  new_classification = 'not coding'
+    new_class = "coding" if (label == "coding" and score > 0.6) else "not coding"
 
-  if(state['ai_agent'] is None):
-    state['ai_agent'] = CurrentAgent()
+    if state["ai_agent"] is None:
+        state["ai_agent"] = CurrentAgent()
 
-  if(highest_score_label == 'coding' and highest_score > 0.6):
-    new_classification = 'coding'
+    return {
+        "ai_agent": state["ai_agent"],
+        "classification": new_class,
+        "messages": state["messages"]
+    }
 
-  return {
-      "ai_agent": state['ai_agent'],
-      "classification": new_classification,
-      "messages": state['messages']
-  }
 
+# -----------------------------
+# GENERAL ASSISTANT NODE
+# -----------------------------
 def general_assistant(state: AgentState) -> AgentState:
-  if(state['ai_agent'] is None):
-    state['ai_agent'] = CurrentAgent()
+    if state["ai_agent"] is None:
+        state["ai_agent"] = CurrentAgent()
 
-  updated_messages = [
-      state['ai_agent'].current_chat.invoke(state['messages'])
-  ]
+    updated = [state["ai_agent"].current_chat.invoke(state["messages"])]
+
+    return {
+        "ai_agent": state["ai_agent"],
+        "classification": state["classification"],
+        "messages": updated
+    }
 
-  return {
-      "ai_agent": state['ai_agent'],
-      "classification": state['classification'],
-      "messages": updated_messages
-  }
 
+# -----------------------------
+# CODE ASSISTANT NODE
+# -----------------------------
 def code_assistant(state: AgentState) -> AgentState:
-  if(state['ai_agent'] is None):
-    state['ai_agent'] = CurrentAgent()
+    if state["ai_agent"] is None:
+        state["ai_agent"] = CurrentAgent()
 
-  state['ai_agent'].update_llm('Qwen/Qwen2.5-Coder-32B-Instruct', hf_token)
-  updated_messages = [
-      state['ai_agent'].current_chat.invoke(state['messages'])
-  ]
+    # The agent will automatically call the code_llm tool
+    updated = [state["ai_agent"].current_chat.invoke(state["messages"])]
 
-  return {
-      "ai_agent": state['ai_agent'],
-      "classification": state['classification'],
-      "messages": updated_messages
-  }
+    return {
+        "ai_agent": state["ai_agent"],
+        "classification": state["classification"],
+        "messages": updated
+    }
 
-def route(state: AgentState):
-    mode = state['classification']
-    if mode == "coding":
-      return "code_assistant"
-    else:
-      return "general_assistant"
 
+# -----------------------------
+# ROUTER
+# -----------------------------
+def route(state: AgentState):
+    return "code_assistant" if state["classification"] == "coding" else "general_assistant"
 
 
+# -----------------------------
+# WORKFLOW
+# -----------------------------
 def build_workflow() -> Any:
-  graph_builder = StateGraph(AgentState)
-  # Define the nodes:
-  graph_builder.add_node("classify", classify)
-  graph_builder.add_node("general_assistant", general_assistant)
-  graph_builder.add_node("code_assistant", code_assistant)
-
-
-  ### Define Edges
-  # The start node, just return the result using chat api with current messages state.
-  graph_builder.add_edge(START, "classify")
-  # Add a conditional edge
-  graph_builder.add_conditional_edges(
-    "classify",
-    route,
-    {
-        "general_assistant": "general_assistant",
-        "code_assistant": "code_assistant"
-    }
-  )
+    graph = StateGraph(AgentState)
+
+    graph.add_node("classify", classify)
+    graph.add_node("general_assistant", general_assistant)
+
+    graph.add_edge(START, "classify")
+    graph.add_edge("classify", "general_assistant")
+    graph.add_edge("general_assistant", END)
 
-  graph_builder.add_edge("general_assistant", END)
-  graph_builder.add_edge("code_assistant", END)
-  return graph_builder.compile()
+    return graph.compile()