Add application file

app.py

@@ -1,8 +1,8 @@
-
 import os
 import gradio as gr
 import datasets
 from typing import List, Tuple
+from functools import lru_cache
 
 # LangChain / LangGraph imports
 # from langchain_core.documents import Document
@@ -11,7 +11,7 @@ from langchain_community.tools import DuckDuckGoSearchRun
 from langchain_huggingface import HuggingFaceEmbeddings
 from langchain_community.vectorstores import FAISS
 from langchain.tools import Tool
-from langchain_core.messages import AnyMessage, HumanMessage, AIMessage, ToolMessage
+from langchain_core.messages import AnyMessage, HumanMessage, AIMessage
 from typing import TypedDict, Annotated
 from langgraph.graph.message import add_messages
 from langgraph.prebuilt import ToolNode
@@ -19,105 +19,131 @@ from langgraph.graph import START, StateGraph
 from langgraph.prebuilt import tools_condition
 from langchain_huggingface import HuggingFaceEndpoint, ChatHuggingFace
 
-def set_token_hfhub(value):
+##############################
+# Token management (supports both env var names)
+##############################
+
+def set_token_hfhub(value: str):
+    """Update both common env var names for HF tokens."""
+    value = (value or "").strip()
     os.environ["HF_TOKEN"] = value
+    os.environ["HUGGINGFACEHUB_API_TOKEN"] = value
+
+
+def _get_token_from_env() -> str:
+    return (
+        os.getenv("HF_TOKEN")
+        or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+        or ""
+    ).strip()
+
+
+##############################
+# 1) Lazy data + retriever build
+##############################
+
+@lru_cache(maxsize=1)
+def build_retriever():
+    """Load dataset, embed, and return a retriever. Cached after first call."""
+    guest_dataset = datasets.load_dataset("agents-course/unit3-invitees", split="train")
+    docs = [
+        Document(
+            page_content="\n".join(
+                [
+                    f"Name: {guest['name']}",
+                    f"Relation: {guest['relation']}",
+                    f"Description: {guest['description']}",
+                    f"Email: {guest['email']}",
+                ]
+            ),
+            metadata={"name": guest["name"]},
+        )
+        for guest in guest_dataset
+    ]
 
-# ==============================
-# 1) Build the same agent (Alfred)
-# ==============================
-
-# Load the dataset and make Documents
-guest_dataset = datasets.load_dataset("agents-course/unit3-invitees", split="train")
-docs = [
-    Document(
-        page_content="\n".join(
-            [
-                f"Name: {guest['name']}",
-                f"Relation: {guest['relation']}",
-                f"Description: {guest['description']}",
-                f"Email: {guest['email']}",
-            ]
-        ),
-        metadata={"name": guest["name"]},
+    embeddings = HuggingFaceEmbeddings(
+        model_name="sentence-transformers/all-MiniLM-L6-v2",
+        encode_kwargs={"normalize_embeddings": True},
     )
-    for guest in guest_dataset
-]
-
-# Embeddings & Vectorstore retriever
-embeddings = HuggingFaceEmbeddings(
-    model_name="sentence-transformers/all-MiniLM-L6-v2",
-    encode_kwargs={"normalize_embeddings": True},
-)
-vectorstore = FAISS.from_documents(docs, embeddings)
-retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 3})
-
-# Guest info tool
+    vectorstore = FAISS.from_documents(docs, embeddings)
+    retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 3})
+    return retriever
+
+
+##############################
+# 2) Tools (use lazy retriever)
+##############################
+
 def extract_text(query: str) -> str:
     """Retrieves detailed information about gala guests based on their name or relation."""
+    retriever = build_retriever()
     results = retriever.invoke(query)
     if results:
         return "\n\n".join([doc.page_content for doc in results])
     else:
         return "No matching guest information found."
 
-guest_info_tool = Tool(
-    name="guest_info_retriever",
-    func=extract_text,
-    description="Retrieves detailed information about gala guests based on their name or relation.",
-)
-
-# Web search tool
-search_tool = DuckDuckGoSearchRun()
 
-# LLM endpoint (reads token from env var or Python var fallback)
-# hf_token = os.getenv("HF_TOKEN")
-hf_token = os.environ["HF_TOKEN"]
-
-if not hf_token:
-    raise RuntimeError(
-        "HUGGINGFACEHUB_API_TOKEN is not set. Please export it before running the app."
+def get_tools():
+    guest_info_tool = Tool(
+        name="guest_info_retriever",
+        func=extract_text,
+        description="Retrieves detailed information about gala guests based on their name or relation.",
     )
+    search_tool = DuckDuckGoSearchRun()
+    return [guest_info_tool, search_tool]
+
 
-llm = HuggingFaceEndpoint(
-    repo_id="Qwen/Qwen2.5-Coder-32B-Instruct",
-    huggingfacehub_api_token=hf_token,
-)
-chat = ChatHuggingFace(llm=llm, verbose=True)
-tools = [guest_info_tool, search_tool]
-chat_with_tools = chat.bind_tools(tools)
+##############################
+# 3) Lazy LLM/chat + graph builders
+##############################
 
-# Agent state & node
 class AgentState(TypedDict):
     messages: Annotated[List[AnyMessage], add_messages]
 
-def assistant(state: AgentState):
-    # Produce one assistant message (may include a tool call)
-    return {"messages": [chat_with_tools.invoke(state["messages"])]}
 
-# Graph wiring
-builder = StateGraph(AgentState)
-builder.add_node("assistant", assistant)
-builder.add_node("tools", ToolNode(tools))
-builder.add_edge(START, "assistant")
-builder.add_conditional_edges("assistant", tools_condition)
-builder.add_edge("tools", "assistant")
-alfred = builder.compile()
+def build_chat(hf_token: str):
+    if not hf_token:
+        raise RuntimeError(
+            "No HF token provided. Enter it in the textbox first."
+        )
+    llm = HuggingFaceEndpoint(
+        repo_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+        huggingfacehub_api_token=hf_token,
+    )
+    return ChatHuggingFace(llm=llm, verbose=True)
+
+
+def build_agent(chat: ChatHuggingFace):
+    tools = get_tools()
+    chat_with_tools = chat.bind_tools(tools)
+
+    def assistant(state: AgentState):
+        # Produce one assistant message (may include a tool call)
+        return {"messages": [chat_with_tools.invoke(state["messages"])]}
+
+    builder = StateGraph(AgentState)
+    builder.add_node("assistant", assistant)
+    builder.add_node("tools", ToolNode(tools))
+    builder.add_edge(START, "assistant")
+    builder.add_conditional_edges("assistant", tools_condition)
+    builder.add_edge("tools", "assistant")
+    return builder.compile()
+
+
+##############################
+# 4) Gradio UI plumbing
+##############################
 
-# ======================================
-# 2) Helper functions for the Gradio UI
-# ======================================
 
 def _msg_content_to_str(msg: AnyMessage) -> str:
     """
     Coerce LangChain message content (which might contain tool call structures)
     into displayable text for the Chatbot.
     """
-    # Most often, content is a string already
     content = getattr(msg, "content", "")
     if isinstance(content, str):
         return content
-
-    # If it's a list of parts (e.g., tool call traces), join any text parts
     if isinstance(content, list):
         texts = []
         for part in content:
@@ -126,27 +152,63 @@ def _msg_content_to_str(msg: AnyMessage) -> str:
             elif isinstance(part, str):
                 texts.append(part)
         return "\n".join(texts) if texts else str(content)
-
-    # Fallback
     return str(content)
 
+
 def startup_state() -> List[AnyMessage]:
     """Start with an empty conversation."""
     return []
 
-# Gradio expects chatbot history as List[Tuple[str, str]]
+
+# Gradio expects chatbot history as list of {role, content} when type="messages"
+
+def setup_runtime(hf_token: str, chatbot, agent_messages, runtime_state):
+    """Initialize chat + agent given a token and store in runtime_state."""
+    try:
+        set_token_hfhub(hf_token)
+        chat = build_chat(_get_token_from_env())
+        alfred = build_agent(chat)
+        runtime_state = {"alfred": alfred}
+        system_note = (
+            "✅ Token set. You can start chatting now!"
+        )
+        chatbot = [
+            {"role": "assistant", "content": system_note}
+        ]
+        agent_messages = startup_state()
+        return gr.update(), chatbot, agent_messages, runtime_state
+    except Exception as e:
+        # Surface the error in the chat UI
+        err = f"⚠️ Failed to initialize model: {e}"
+        chatbot = [{"role": "assistant", "content": err}]
+        return gr.update(), chatbot, agent_messages, runtime_state
+
+
 def submit_user_message(
     user_text: str,
-    chat_history: List[Tuple[str, str]],
+    chat_history: List[dict],
     agent_messages: List[AnyMessage],
+    runtime_state: dict,
 ):
     """
     1) Append HumanMessage to agent state
-    2) Run Alfred
+    2) Run Alfred (lazy-initialized)
     3) Extract last AIMessage and append to chat_history
     """
     if not user_text or user_text.strip() == "":
-        return gr.update(), chat_history, agent_messages
+        return gr.update(), chat_history, agent_messages, runtime_state
+
+    # Ensure agent is initialized
+    alfred = (runtime_state or {}).get("alfred")
+    if alfred is None:
+        # If there's no agent yet, ask for a token
+        note = (
+            "🔐 Please enter your Hugging Face token above and press Enter to initialize the model."
+        )
+        chat_history = list(chat_history or [])
+        chat_history.append({"role": "user", "content": user_text})
+        chat_history.append({"role": "assistant", "content": note})
+        return "", chat_history, agent_messages, runtime_state
 
     # Step 1: add HumanMessage to state
     agent_messages = list(agent_messages or [])
@@ -155,10 +217,9 @@ def submit_user_message(
     # Step 2: run the graph
     out = alfred.invoke({"messages": agent_messages})
 
-    # The graph returns a new messages list *including* the latest assistant/tool steps.
-    # We use the last AIMessage as the displayed reply.
+    # Graph returns full messages list including assistant/tool steps
     new_msgs: List[AnyMessage] = out["messages"]
-    agent_messages = new_msgs  # keep full state for the next turn
+    agent_messages = new_msgs
 
     # Find the last assistant message to show in the UI
     ai_text = ""
@@ -167,21 +228,22 @@ def submit_user_message(
             ai_text = _msg_content_to_str(m)
             break
     if not ai_text:
-        # fallback: in rare cases of only tool messages, show a generic note
         ai_text = "I processed your request using my tools."
 
     chat_history = list(chat_history or [])
     chat_history.append({"role": "user", "content": user_text})
     chat_history.append({"role": "assistant", "content": ai_text})
-    return "", chat_history, agent_messages
+    return "", chat_history, agent_messages, runtime_state
+
 
-def clear_chat():
-    """Reset the Gradio UI and agent state."""
-    return [], startup_state()
+def clear_chat(runtime_state: dict):
+    """Reset the visible chat but keep the initialized agent (if any)."""
+    return [], startup_state(), runtime_state
 
-# ========================
-# 3) Gradio App UI layout
-# ========================
+
+##############################
+# 5) Gradio App UI layout
+##############################
 
 with gr.Blocks(title="Alfred — LangGraph Agent") as demo:
     gr.Markdown(
@@ -190,12 +252,15 @@ with gr.Blocks(title="Alfred — LangGraph Agent") as demo:
         Ask questions and Alfred will respond, using:
         - a vector search tool over the guest list
         - DuckDuckGo web search
+        
+        **Setup:** Paste your Hugging Face token below and press Enter.
         """
     )
 
-    with gr.Row(): 
+    with gr.Row():
         token1 = gr.Textbox(
-            label="Your hf token",
+            label="Your HF token",
+            placeholder="hf_...",
             autofocus=True,
             scale=2,
         )
@@ -206,29 +271,48 @@ with gr.Blocks(title="Alfred — LangGraph Agent") as demo:
             type="messages",
             height=500,
             show_copy_button=True,
-            avatar_images=(None, None),  # customize if you like
+            avatar_images=(None, None),
         )
 
     with gr.Row():
         txt = gr.Textbox(
             label="Your message",
             placeholder="Ask anything…",
-            autofocus=True,
+            autofocus=False,
             scale=4,
         )
         send_btn = gr.Button("Send", variant="primary", scale=1)
         clear_btn = gr.Button("Clear")
 
-    # Hidden state: the agent’s full message list (LangChain messages)
-    agent_state = gr.State(startup_state())
+    # Hidden states
+    agent_state = gr.State(startup_state())           # LangChain messages
+    runtime_state = gr.State({"alfred": None})       # Holds compiled agent
 
     # Wire up events
-    token1.submit(set_token_hfhub, [token1])
-    txt.submit(submit_user_message, [txt, chatbot, agent_state], [txt, chatbot, agent_state])
-    send_btn.click(submit_user_message, [txt, chatbot, agent_state], [txt, chatbot, agent_state])
-    clear_btn.click(clear_chat, outputs=[chatbot, agent_state])
+    # Token submit initializes the runtime (sets env var, builds chat + graph)
+    token1.submit(
+        setup_runtime,
+        inputs=[token1, chatbot, agent_state, runtime_state],
+        outputs=[token1, chatbot, agent_state, runtime_state],
+    )
+
+    txt.submit(
+        submit_user_message,
+        [txt, chatbot, agent_state, runtime_state],
+        [txt, chatbot, agent_state, runtime_state],
+    )
+    send_btn.click(
+        submit_user_message,
+        [txt, chatbot, agent_state, runtime_state],
+        [txt, chatbot, agent_state, runtime_state],
+    )
+    clear_btn.click(
+        clear_chat,
+        inputs=[runtime_state],
+        outputs=[chatbot, agent_state, runtime_state],
+    )
 
 # Entry point
 if __name__ == "__main__":
     # You can tweak server_name/port as needed
-    demo.launch()
+    demo.launch()

requirement.txt

@@ -1,6 +1,8 @@
 gradio
 langchain
-langchain-huggingface
+langgraph
+langchain-community
+langchain_huggingface
 datasets
 faiss-cpu
 ddgs