update

Dockerfile

@@ -8,4 +8,5 @@ RUN pip install -r requirements.txt
 COPY . .
 
 # Hugging Face Space 必须监听 7860 端口
-CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "7860"]
+# 用 supervisor 同时跑 FastAPI(8008) + Gradio(7860)
+CMD ["supervisord", "-c", "supervisord.conf"]

README.md

@@ -1,5 +1,5 @@
 ---
-title: Bio QA Agent
+title: Bio QA Agent Gradio + MCP
 emoji: 💬
 colorFrom: yellow
 colorTo: purple

app.py

@@ -1,70 +1,117 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
+import httpx
+import asyncio
+import json
 
+API_URL = "http://localhost:8008/stream-words"
 
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
+async def stream_words(query: str):
+    """异步获取 FastAPI 的流式输出"""
+    async with httpx.AsyncClient(timeout=None) as client:
+        async with client.stream("GET", API_URL, params={"query": query}) as response:
+            async for line in response.aiter_lines():
+                if line.startswith("data: "):
+                    try:
+                        data = json.loads(line[6:])
+                        if data.get('status') == 'word':
+                            yield data.get('word', '')
+                        elif data.get('status') == 'start':
+                            yield f"🚀 {data.get('message', '开始生成单词...')}\n"
+                        elif data.get('status') == 'complete':
+                            yield f"\n✅ {data.get('message', '生成完成！')}"
+                    except json.JSONDecodeError:
+                        continue
 
-    messages = [{"role": "system", "content": system_message}]
+def stream_words_mcp(query: str):
+    """MCP工具包装函数：流式获取英文单词，返回结果给MCP客户端"""
+    try:
+        # 调用原始函数并收集结果
+        result = []
+        # 注意：这里需要处理异步函数
+        async def collect_tokens():
+            async for token in stream_words(query):
+                if token.strip():
+                    result.append(token)
+            return result
+        
+        # 运行异步函数
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        tokens = loop.run_until_complete(collect_tokens())
+        loop.close()
+        
+        # 返回结果给MCP客户端
+        return f"成功生成 {len(tokens)} 个英文单词: {', '.join(tokens[:10])}{'...' if len(tokens) > 10 else ''}"
+    except Exception as e:
+        return f"生成单词时出错: {str(e)}"
 
-    messages.extend(history)
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🧠 English Words Generator")
+    gr.Markdown("输入你的查询，AI 将为你生成 200 个英文单词（流式输出）")
+    
+    chatbot = gr.Chatbot(
+        type="messages",
+        height=500,
+        show_label=False,
+        container=True,
+        bubble_full_width=False
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=8):
+            query_input = gr.Textbox(
+                placeholder="输入你的查询，比如：'给我一些常用英文单词'",
+                label="",
+                show_label=False,
+                lines=2
+            )
+        with gr.Column(scale=1):
+            send_btn = gr.Button("发送", variant="primary", size="lg")
+        with gr.Column(scale=1):
+            clear_btn = gr.Button("清空", variant="secondary")
 
-    messages.append({"role": "user", "content": message})
+    def handle_user_input(query, messages):
+        """添加用户消息"""
+        if query.strip():
+            new_messages = messages + [{"role": "user", "content": query}]
+            return "", new_messages
+        return query, messages
 
-    response = ""
+    def clear_chat():
+        """清空对话"""
+        return []
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
+    async def generate_response(messages):
+        """根据用户最后一条消息流式生成 AI 回复"""
+        if not messages or messages[-1]["role"] != "user":
+            yield messages
+            return
 
-        response += token
-        yield response
+        last_user_msg = messages[-1]["content"]
 
+        # 添加 AI 回复占位符
+        messages.append({"role": "assistant", "content": "正在生成单词..."})
+        yield messages
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    type="messages",
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+        # 流式拼接回复
+        full_response = ""
+        async for token in stream_words(last_user_msg):
+            if token.strip():
+                full_response += " " + token
+                messages[-1] = {"role": "assistant", "content": full_response.strip()}
+                yield messages
 
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
+    # 用户提交时，先加消息 → 再生成回复
+    query_input.submit(handle_user_input, inputs=[query_input, chatbot], outputs=[query_input, chatbot])\
+              .then(generate_response, inputs=chatbot, outputs=chatbot)
 
+    send_btn.click(handle_user_input, inputs=[query_input, chatbot], outputs=[query_input, chatbot])\
+            .then(generate_response, inputs=chatbot, outputs=chatbot)
 
-if __name__ == "__main__":
-    demo.launch()
+    clear_btn.click(clear_chat, outputs=chatbot)
+
+    # 注册MCP工具 - 使用包装函数并正确配置输出
+    demo.load(stream_words_mcp, inputs=None, outputs=gr.Textbox(label="MCP结果", visible=False))
+
+# 开启 MCP server
+demo.launch(mcp_server=True, server_port=7860)

requirements.txt

@@ -1,2 +1,6 @@
+gradio[mcp]>=4.36.0
+httpx
 fastapi
 uvicorn
+supervisor
+httpx

server.py

@@ -1,11 +1,77 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
+from fastapi.responses import StreamingResponse
+import asyncio
+import json
+from typing import AsyncGenerator
 
-app = FastAPI()
+app = FastAPI(title="Streaming English Words API", version="1.0.0")
 
-@app.get("/ping")
-def ping():
-    return {"msg": "MCP server running on Hugging Face Space!"}
+# 预定义的200个常用英文单词
+ENGLISH_WORDS = [
+    "the", "be", "to", "of", "and", "a", "in", "that", "have", "I",
+    "it", "for", "not", "on", "with", "he", "as", "you", "do", "at",
+    "this", "but", "his", "by", "from", "they", "we", "say", "her", "she",
+    "or", "an", "will", "my", "one", "all", "would", "there", "their", "what",
+    "so", "up", "out", "if", "about", "who", "get", "which", "go", "me",
+    "when", "make", "can", "like", "time", "no", "just", "him", "know", "take",
+    "people", "into", "year", "your", "good", "some", "could", "them", "see", "other",
+    "than", "then", "now", "look", "only", "come", "its", "over", "think", "also",
+    "back", "after", "use", "two", "how", "our", "work", "first", "well", "way",
+    "even", "new", "want", "because", "any", "these", "give", "day", "most", "us",
+    "very", "life", "after", "call", "world", "over", "still", "take", "every", "through",
+    "before", "long", "where", "much", "should", "well", "people", "down", "own", "work",
+    "first", "good", "new", "write", "our", "used", "me", "man", "too", "any",
+    "day", "same", "right", "look", "think", "also", "around", "another", "came"
+]
 
-@app.post("/tools/add")
-def add(a: int, b: int):
-    return {"result": a + b}
+async def generate_words_stream(query: str) -> AsyncGenerator[str, None]:
+    """生成200个英文单词的流式输出"""
+    # 发送开始标记
+    yield f"data: {json.dumps({'status': 'start', 'query': query, 'message': '开始生成200个英文单词...'})}\n\n"
+    
+    # 流式输出200个单词
+    for i, word in enumerate(ENGLISH_WORDS, 1):
+        # 模拟一些处理时间，让流式效果更明显
+        await asyncio.sleep(0.05)
+        
+        # 发送单词数据
+        data = {
+            'status': 'word',
+            'index': i,
+            'word': word,
+            'total': len(ENGLISH_WORDS)
+        }
+        yield f"data: {json.dumps(data)}\n\n"
+    
+    # 发送完成标记
+    yield f"data: {json.dumps({'status': 'complete', 'message': '200个英文单词生成完成！'})}\n\n"
+
+@app.get("/")
+async def root():
+    return {"message": "Streaming English Words API", "endpoint": "/stream-words"}
+
+@app.get("/stream-words")
+async def stream_words(query: str = "default"):
+    """流式输出200个英文单词"""
+    return StreamingResponse(
+        generate_words_stream(query),
+        media_type="text/plain",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "Content-Type": "text/event-stream",
+        }
+    )
+
+@app.get("/words")
+async def get_words(query: str = "default"):
+    """一次性返回所有200个英文单词"""
+    return {
+        "query": query,
+        "total_words": len(ENGLISH_WORDS),
+        "words": ENGLISH_WORDS
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8008) 

supervisord.conf

@@ -0,0 +1,16 @@
+[supervisord]
+nodaemon=true
+
+[program:fastapi]
+command=uvicorn server:app --host 0.0.0.0 --port 8008
+autostart=true
+autorestart=true
+stdout_logfile=/dev/stdout
+stderr_logfile=/dev/stderr
+
+[program:gradio]
+command=python app.py
+autostart=true
+autorestart=true
+stdout_logfile=/dev/stdout
+stderr_logfile=/dev/stderr