Spaces:
Sleeping
Sleeping
Download app.py from german-chatbot/README: direct link, hf CLI and curl.
- Browser
- Download file 9.91 kB
-
https://huggingface.co/spaces/german-chatbot/README/resolve/main/app.py
- Command line
-
hf download hf://spaces/german-chatbot/README/app.py
-
curl -L -o app.py https://huggingface.co/spaces/german-chatbot/README/resolve/main/app.py
9.91 kB
| import os | |
| import uuid | |
| import json | |
| from datetime import datetime | |
| from dotenv import load_dotenv | |
| load_dotenv() | |
| from supabase import create_client | |
| from langchain_core.runnables import RunnableConfig | |
| from typing import TypedDict, List, Optional, Annotated, Literal | |
| from langchain_core.messages import BaseMessage, AIMessage, HumanMessage, SystemMessage | |
| from langgraph.graph.message import add_messages | |
| from langgraph.graph import StateGraph, END | |
| from langchain_openai import OpenAIEmbeddings | |
| from langchain.chat_models import init_chat_model | |
| from langchain_pinecone import Pinecone as LangchainPinecone | |
| from langchain_core.chat_history import BaseChatMessageHistory | |
| from langchain_core.messages import messages_from_dict, messages_to_dict | |
| from pydantic import BaseModel, Field | |
| from relevant_links import RELEVANT_NATURALIZATION_LINKS | |
| from prompts import SYSTEM_MESSAGE_TEXT, ROUTER_SYS | |
| # --- Supabase Setup --- | |
| SUPABASE_URL = os.getenv("SUPABASE_URL") | |
| SUPABASE_KEY = os.getenv("SUPABASE_KEY") | |
| supabase = create_client(SUPABASE_URL, SUPABASE_KEY) | |
| # --- Custom State --- | |
| class CustomState(TypedDict): | |
| messages: Annotated[List[BaseMessage], add_messages] | |
| user_id: str | |
| chat_history: Optional[List[List[str]]] | |
| # --- Router Structured Output Schema (SINGLE MODEL) --- | |
| class RouterDecision(BaseModel): | |
| action: Literal["reply", "retrieve"] | |
| language: Literal["de", "en", "tr", "ar"] | |
| text: Optional[str] = None | |
| normalized_query: Optional[str] = None | |
| # --- AI Models --- | |
| if not os.environ.get("OPENAI_API_KEY"): | |
| os.environ["OPENAI_API_KEY"] = input("Enter API key for OpenAI: ") | |
| llm = init_chat_model("gpt-4.1", model_provider="openai", temperature=0.5) | |
| # router with structured output using the single model | |
| _router_llm_base = init_chat_model("gpt-4.1", model_provider="openai", temperature=0.7) | |
| router_llm = _router_llm_base.with_structured_output( | |
| schema=RouterDecision, | |
| method="json_schema" | |
| ) | |
| # --- Vector Store --- | |
| pinecone_api_key = os.getenv("PINECONE_API_KEY", "").strip() | |
| pinecone_index_name = os.getenv("PINECONE_INDEX_NAME", "").strip() | |
| embeddings = OpenAIEmbeddings(model="text-embedding-3-large") | |
| vector_store = LangchainPinecone( | |
| index_name=pinecone_index_name, | |
| embedding=embeddings, | |
| pinecone_api_key=pinecone_api_key | |
| ) | |
| # --- Supabase Chat Memory --- | |
| class SupabaseChatMessageHistory(BaseChatMessageHistory): | |
| def __init__(self, user_id: str, supabase_client): | |
| self.user_id = user_id | |
| self.supabase = supabase_client | |
| def messages(self): | |
| response = self.supabase.table("chat_memory").select("*").eq("user_id", self.user_id).execute() | |
| data = response.data[0] if response.data else {} | |
| return messages_from_dict(data.get("messages", [])) | |
| def add_message(self, message): | |
| all_messages = messages_to_dict(self.messages + [message]) | |
| self.supabase.table("chat_memory").upsert({ | |
| "user_id": self.user_id, | |
| "messages": all_messages | |
| }).execute() | |
| def add_user_message(self, content: str): | |
| self.add_message(HumanMessage(content=content)) | |
| def add_ai_message(self, content: str): | |
| self.add_message(AIMessage(content=content)) | |
| def clear(self): | |
| self.supabase.table("chat_memory").delete().eq("user_id", self.user_id).execute() | |
| class MemoryStore: | |
| def get_memory(self, user_id: str): | |
| return SupabaseChatMessageHistory(user_id, supabase) | |
| store = MemoryStore() | |
| # --- Logging --- | |
| def log_interaction_cloud(user_id: str, question: str, answer: str): | |
| payload = { | |
| "user_id": user_id, | |
| "question": question, | |
| "answer": answer, | |
| "timestamp": datetime.utcnow().isoformat(), | |
| } | |
| try: | |
| res = supabase.table("logs").insert(payload).execute() | |
| print("[Supabase Log Success]:", res.data) | |
| except Exception as e: | |
| print("[Supabase Log Error]:", e) | |
| # --- Retrieval --- | |
| def retrieve(query: str): | |
| retrieved_docs = vector_store.similarity_search(query, k=4) | |
| serialized = "\n\n".join( | |
| (f"[Source]({doc.metadata.get('source', '')}):\n{doc.page_content}") | |
| for doc in retrieved_docs | |
| ) | |
| return serialized, retrieved_docs | |
| def generate_user_id(): | |
| return "user_" + uuid.uuid4().hex[:6] | |
| # --- STRICT Router (Structured Output + Retry + Runtime guards) --- | |
| def route_or_reply(user_text: str, prior_msgs: List[BaseMessage]) -> dict: | |
| history_slice = prior_msgs[-4:] if prior_msgs else [] | |
| msgs = [SystemMessage(ROUTER_SYS)] + history_slice + [HumanMessage(user_text)] | |
| last_err = None | |
| for attempt in range(2): | |
| try: | |
| obj = router_llm.invoke(msgs) | |
| data = obj.model_dump() | |
| action = data.get("action") | |
| if action == "reply": | |
| if not data.get("text"): | |
| raise ValueError("RouterDecision 'reply' requires 'text'.") | |
| data.pop("normalized_query", None) | |
| elif action == "retrieve": | |
| if not data.get("normalized_query"): | |
| raise ValueError("RouterDecision 'retrieve' requires 'normalized_query'.") | |
| data.pop("text", None) | |
| else: | |
| raise ValueError(f"Unknown action: {action}") | |
| return data | |
| except Exception as e: | |
| last_err = e | |
| print(f"[Router Parse/Validation Error Attempt {attempt+1}]:", repr(e)) | |
| return {"action": "reply", "language": "en", "text": "Sorry, something went wrong. Please try again."} | |
| # --- Main Node --- | |
| def query_or_respond(state: CustomState) -> CustomState: | |
| user_id = state.get("user_id") or generate_user_id() | |
| human_messages = [m for m in state["messages"] if m.type == "human"] | |
| latest_user_msg = human_messages[-1] | |
| memory = store.get_memory(user_id) | |
| history = memory.messages | |
| decision = route_or_reply(latest_user_msg.content, history) | |
| print("[Router]", decision) | |
| if decision.get("action") == "reply": | |
| response = AIMessage(content=decision.get("text", "")) | |
| memory.add_user_message(latest_user_msg.content) | |
| memory.add_ai_message(response.content) | |
| #log_interaction_cloud(user_id, latest_user_msg.content, response.content) | |
| return {**state, "messages": [response], "user_id": user_id} | |
| normalized_query = decision.get("normalized_query") or latest_user_msg.content | |
| retrieved_text, _ = retrieve(normalized_query) | |
| history_tail = history[-5:] | |
| system_msg = SystemMessage( | |
| SYSTEM_MESSAGE_TEXT | |
| + "\n\nStrictly use the following documents to answer the question. " | |
| "If helpful, include direct source links in your answer: " | |
| + retrieved_text | |
| ) | |
| prompt = [system_msg] + history_tail + [latest_user_msg] | |
| response = llm.invoke(prompt) | |
| print("The retrieved text is ", retrieved_text) | |
| memory.add_user_message(latest_user_msg.content) | |
| memory.add_ai_message(response.content) | |
| log_interaction_cloud(user_id, latest_user_msg.content, response.content) | |
| return {**state, "messages": [response], "user_id": user_id} | |
| # --- Graph --- | |
| graph_builder = StateGraph(CustomState) | |
| graph_builder.add_node("query_or_respond", query_or_respond) | |
| graph_builder.set_entry_point("query_or_respond") | |
| graph_builder.add_edge("query_or_respond", END) | |
| graph = graph_builder.compile() | |
| # --- Gradio UI --- | |
| import gradio as gr | |
| def clear_history(user_id_state): | |
| if user_id_state: | |
| store.get_memory(user_id_state).clear() | |
| return [["", "Ich bin hier, um Ihnen bei allen Fragen zur Einbürgerung in Deutschland zu helfen..."]], user_id_state, "", user_id_state | |
| def respond(user_message, chatbot, user_id_input, chat_state, user_id_state): | |
| if not user_message: | |
| return chatbot, chat_state, user_id_input, "", user_id_state | |
| user_id = user_id_state or user_id_input or generate_user_id() | |
| state: CustomState = { | |
| "messages": [HumanMessage(content=user_message)], | |
| "user_id": user_id, | |
| "chat_history": None | |
| } | |
| config = RunnableConfig(configurable={"session_id": user_id}) | |
| final_state = graph.invoke(state, config=config) | |
| bot_response = final_state["messages"][-1].content | |
| chatbot.append([user_message, bot_response]) | |
| return chatbot, chatbot, user_id, "", user_id | |
| description = """ | |
| ### Was ist **Einbürgerungs-Helfer**? | |
| **Deutsch:** Einbürgerungs-Helfer hilft dir, den Weg zur deutschen Staatsangehörigkeit zu verstehen – einfach, mehrsprachig, datenschutzfreundlich. | |
| """ | |
| with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue")) as iface: | |
| gr.Markdown(f"# Einbürgerungs-Helfer\n{description}") | |
| with gr.Row(): | |
| user_id_input = gr.Textbox(label="Benutzer-ID (User ID)", placeholder="z.B. user_123", lines=1) | |
| clear_btn = gr.Button("🗑️ Verlauf löschen") | |
| user_id_state = gr.State(value="") | |
| chat_state = gr.State([]) | |
| chatbot = gr.Chatbot( | |
| label="Chat", | |
| show_copy_button=True, | |
| value=[[None, "Ich bin hier, um Ihnen bei allen Fragen zur Einbürgerung in Deutschland zu helfen.\nLassen Sie uns loslegen – wie kann ich Ihnen heute helfen?"]] | |
| ) | |
| msg_input = gr.Textbox(placeholder="Frage eingeben...", label="Deine Nachricht", lines=1, value="") | |
| with gr.Row(): | |
| submit_btn = gr.Button("Senden", variant="primary") | |
| submit_btn.click(fn=respond, inputs=[msg_input, chatbot, user_id_input, chat_state, user_id_state], outputs=[chatbot, chat_state, user_id_input, msg_input, user_id_state]) | |
| msg_input.submit(fn=respond, inputs=[msg_input, chatbot, user_id_input, chat_state, user_id_state], outputs=[chatbot, chat_state, user_id_input, msg_input, user_id_state]) | |
| clear_btn.click(fn=clear_history, inputs=[user_id_state], outputs=[chatbot, user_id_input, msg_input, user_id_state]) | |
| iface.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)), share=True) | |