python verbose run command in dockerfile fixes output hang; minor fixes for mcp documention

Dockerfile

@@ -8,10 +8,10 @@ COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
 # copy app
-COPY app.py .
+COPY app ./app
 
 # expose Gradio default port
 EXPOSE 7860
 
-# launch
-CMD ["python", "app.py"]
+# launch with unbuffered output
+CMD ["python", "-u", "app/main.py"]

app/main.py

@@ -1,49 +1,80 @@
 import gradio as gr
 from gradio_client import Client
-from langgraph import Graph, NodeFunction
+from langgraph.graph import StateGraph, START, END
+from typing import TypedDict
 
-# node 1: call your retriever
-def retrieve_node(query: str):
+# Define the state schema
+class GraphState(TypedDict):
+    query: str
+    context: str
+    result: str
+
+# node 1: retriever
+def retrieve_node(state: GraphState) -> GraphState:
     client = Client("giz/chatfed_retriever")  # HF repo name
-    return client.predict(
-        query=query,
+    context = client.predict(
+        query=state["query"],
         reports_filter="",
         sources_filter="",
         subtype_filter="",
         year_filter="",
         api_name="/retrieve"
     )
+    return {"context": context}
 
-# node 2: call your generator
-def generate_node(query: str, context: str):
+# node 2: generator
+def generate_node(state: GraphState) -> GraphState:
     client = Client("giz/chatfed_generator")
-    return client.predict(
-        query=query,
-        context=context,
+    result = client.predict(
+        query=state["query"],
+        context=state["context"],
         api_name="/generate"
     )
+    return {"result": result}
 
 # build the graph
-graph = Graph()
-n1 = graph.add_node(NodeFunction(retrieve_node), name="retrieve")
-n2 = graph.add_node(NodeFunction(generate_node), name="generate")
-graph.link(n1, n2)
+workflow = StateGraph(GraphState)
+
+# Add nodes
+workflow.add_node("retrieve", retrieve_node)
+workflow.add_node("generate", generate_node)
+
+# Add edges
+workflow.add_edge(START, "retrieve")
+workflow.add_edge("retrieve", "generate")
+workflow.add_edge("generate", END)
+
+# Compile the graph
+graph = workflow.compile()
 
-# expose a simple Gradio interface that drives the graph
 def pipeline(query: str):
-    # run the graph: pass query into retrieve, then into generate
-    result = graph.run({
-        "retrieve": {"query": query}
-    })
-    return result["generate"]
+    """
+    Execute the ChatFed orchestration pipeline to process a user query.
+    
+    This function orchestrates a two-step workflow:
+    1. Retrieve relevant context using the ChatFed retriever service
+    2. Generate a response using the ChatFed generator service with the retrieved context
+    
+    Args:
+        query (str): The user's input query/question to be processed
+        
+    Returns:
+        str: The generated response from the ChatFed generator service
+    """
+    # run the graph with the initial state
+    initial_state = {"query": query, "context": "", "result": ""}
+    final_state = graph.invoke(initial_state)
+    return final_state["result"]
 
-iface = gr.Interface(
+ui = gr.Interface(
     fn=pipeline,
-    inputs=gr.Textbox(lines=2, placeholder="Enter your question here..."),
+    inputs=gr.Textbox(lines=2, placeholder="Enter query here"),
     outputs="text",
-    title="Modular RAG Pipeline",
+    title="ChatFed Orchestrator",
 )
 
 if __name__ == "__main__":
-    # when HF spins up your container it will pick up port 7860 by default
-    iface.launch(server_name="0.0.0.0", server_port=7860)
+    ui.launch(server_name="0.0.0.0",
+              server_port=7860,
+              mcp_server=True,
+              show_error=True)

requirements.txt

@@ -1,8 +1,4 @@
 gradio[mcp]
-langchain
-langchain-community
-qdrant-client
-sentence-transformers
-gradio_client>=0.10.0
-huggingface_hub>=0.20.0
-torch
+gradio_client>=1.0.0
+langgraph>=0.2.0
+