import os import urllib.request from dotenv import load_dotenv import gradio as gr import fasttext # Download fastText model if not present FASTTEXT_MODEL_PATH = "/tmp/lid.176.bin" if not os.path.exists(FASTTEXT_MODEL_PATH): print("Downloading fastText language identification model...") urllib.request.urlretrieve( "https://dl.fbaipublicfiles.com/fasttext/supervised-models/lid.176.bin", FASTTEXT_MODEL_PATH ) # Load environment variables load_dotenv() # Import your other dependencies from langchain.memory import ConversationBufferWindowMemory from langchain_openai import OpenAIEmbeddings from langchain.chat_models import init_chat_model from langchain_pinecone import Pinecone as LangchainPinecone from supabase import create_client, Client from datetime import datetime from langgraph.graph import MessagesState, StateGraph, END from langchain_core.messages import AIMessage, HumanMessage, SystemMessage from langgraph.prebuilt import ToolNode, tools_condition from langchain_core.tools import tool # Load fastText model fasttext_model = fasttext.load_model(FASTTEXT_MODEL_PATH) SUPPORTED_LANGUAGES = { "de": "German", "en": "English", "tr": "Turkish", "ar": "Arabic" } def detect_supported_language(text): try: label, prob = fasttext_model.predict(text) lang = label[0].replace("__label__", "") if lang in SUPPORTED_LANGUAGES and prob[0] > 0.45: return lang return None except Exception as e: print("[fastText Exception]", e) return None # Set up OpenAI, Pinecone, Supabase, etc. OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY") if not OPENAI_API_KEY: raise RuntimeError("OPENAI_API_KEY must be set in your environment or .env file") llm = init_chat_model("gpt-4.1-2025-04-14", model_provider="openai", temperature=0.0) 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_URL = os.environ.get("SUPABASE_URL") SUPABASE_KEY = os.environ.get("SUPABASE_KEY") supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY) 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() except Exception as e: print("[Supabase Exception]", e) return if hasattr(res, "status_code") and res.status_code >= 400: print(f"[Supabase Error #{res.status_code}]:", res.data) else: print("[Supabase Success]:", res.data) # LangGraph setup (your nodes, graph, etc.) SYSTEM_MESSAGE_TEXT = ( "You are “Einbürgerungs-Helfer”, a highly skilled, friendly, and helpful administrative" " assistant in Germany. Your only task is to support people who are eligible for naturalization" " but have not yet applied. You only answer questions related to the current naturalization" " process in Germany. You do not fill in applications or help users apply. You guide users " "to relevant official resources by calling the retrieval tool to fetch appropriate documents." "Any question involving citizenship, naturalization, applying for German nationality, duration " "of residency, language requirements, or documents required MUST be interpreted as relevant and" " MUST trigger the retrieval tool and never rely on your pre-trained knowledge. Your" "answers must always be accurate, concise, and easy to understand. You must only answer in the user's" "chosen language (German, English, Turkish, or Arabic). If a user writes in a different language" " or requests another language, reply with: “Leider kann ich nur in den folgenden Sprachen" " lesen und schreiben: Deutsch, Englisch, Türkisch oder Arabisch. In welcher Sprache möchten" " Sie weitermachen?” and wait for the user to choose a supported language. You must always" " answer in the chosen language. Never hallucinate, never go beyond the topic of naturalization," " and never share false information. If a user asks a question that is unrelated to naturalizatio" " in Germany, reply in the user's language with: “I can only answer questions related to the" " process of naturalization in Germany. Please provide questions on this topic.” If you do not" " know how to answer, respond with: “I do not have enough knowledge to answer your question" " accurately. Please email your question at SBD-Umfrage@polsoz.fu-berlin.de, and we will answer" " your inquiry as soon as possible.” If a user uses toxic or offensive language, kindly ask them" " to rephrase their question and explain that this behavior is not acceptable." ) @tool(response_format="content_and_artifact") def retrieve(query: str): """Retrieve information related to the last query.""" retrieved_docs = vector_store.similarity_search(query, k=5) serialized = "\n\n".join( (f"Source: {doc.metadata}\n" f"Content: {doc.page_content}") for doc in retrieved_docs ) return serialized, retrieved_docs def query_or_respond(state: MessagesState): latest_user_msg = [m for m in state["messages"] if m.type == "human"][-1] language = state.get("language") if not language: detected_lang = detect_supported_language(latest_user_msg.content) if not detected_lang: return { "messages": state["messages"] + [ AIMessage(content="Leider kann ich nur in den folgenden Sprachen lesen und schreiben: Deutsch, Englisch, Türkisch oder Arabisch. In welcher Sprache möchten Sie weitermachen?") ]} else: state["language"] = detected_lang detected_lang = detect_supported_language(latest_user_msg.content) if detected_lang and detected_lang != state.get("language"): state["language"] = detected_lang if not detected_lang: return { "messages": state["messages"] + [ AIMessage(content="Leider kann ich nur in den folgenden Sprachen lesen und schreiben: Deutsch, Englisch, Türkisch oder Arabisch. In welcher Sprache möchten Sie weitermachen?") ] } system_message = SystemMessage(SYSTEM_MESSAGE_TEXT + f"\n\nThe user is communicating in: {SUPPORTED_LANGUAGES[state['language']]}.") raw_hist = [] if "chat_history" in state: for pair in state["chat_history"]: if len(pair) == 2: raw_hist.append(HumanMessage(content=pair[0])) raw_hist.append(AIMessage(content=pair[1])) OFF_TOPIC_RESPONSE_SNIPPET = "I can only answer questions related to the process of naturalization in Germany" filtered_history = [ msg for msg in raw_hist if not (msg.type == "ai" and OFF_TOPIC_RESPONSE_SNIPPET in msg.content) ] history = filtered_history[-5:] if filtered_history else [] latest_user_msg = [m for m in state["messages"] if m.type == "human"][-1] prompt = [system_message] + history + [latest_user_msg] llm_with_tools = llm.bind_tools([retrieve]) response = llm_with_tools.invoke(prompt) if not getattr(response, "tool_calls", None): user_id = state.get("user_id", "anonymous") log_interaction_cloud(user_id, latest_user_msg.content, response.content) return {"messages": state["messages"] + [response]} tools_node = ToolNode([retrieve]) def generate(state: MessagesState): language = state.get("language", "en") system_prompt = SYSTEM_MESSAGE_TEXT + f"\n\nRespond in: {SUPPORTED_LANGUAGES[language]}.\n\n" recent_tool_messages = [] for msg in reversed(state["messages"]): if msg.type == "tool": recent_tool_messages.append(msg) else: break tool_messages = recent_tool_messages[::-1] docs_content = "\n\n".join(msg.content for msg in tool_messages) system_prompt = SYSTEM_MESSAGE_TEXT + ("\n\n" + docs_content if docs_content else "") MAX_CONTEXT_MESSAGES = 5 conversation_messages = [] for msg in state["messages"]: if msg.type == "human": conversation_messages.append(msg) elif msg.type == "ai": # drop any assistant message that still has a pending tool_call if not getattr(msg, "tool_calls", None): conversation_messages.append(msg) recent_context = conversation_messages[-MAX_CONTEXT_MESSAGES:] # Step 4: Build final prompt prompt = [SystemMessage(system_prompt)] + recent_context # Step 5: Generate response response = llm.invoke(prompt) # Logging final answer # pull out the same user_id you used in the beginning user_id = state.get("user_id", "unknown_user") # the last human message is the question human_messages = [m.content for m in state["messages"] if m.type == "human"] question = human_messages[-1] if human_messages else "" answer = response.content log_interaction_cloud(user_id, question, answer) return {"messages": state["messages"] + [response]} #Finally, we compile our application into a single graph object. In this case, # we are just connecting the steps into a sequence. We also allow the first # query_or_respond step to "short-circuit" and respond directly to the user if # it does not generate a tool call. This allows our application to support # conversational experiences-- e.g., responding to generic greetings that # may not require a retrieval step. g = StateGraph(MessagesState) g.add_node(query_or_respond) g.add_node(tools_node) g.add_node(generate) g.set_entry_point("query_or_respond") g.add_conditional_edges("query_or_respond", tools_condition, {END: END, "tools": "tools"}) g.add_edge("tools", "generate") g.add_edge("generate", END) graph = g.compile() import gradio as gr OFF_TOPIC_SNIPPET = "I can only answer questions related to the process of naturalization" from langchain.memory import ConversationBufferWindowMemory def get_fresh_memory(user_id): return ConversationBufferWindowMemory( memory_key="chat_history", return_messages=True, k=5 ) def get_memory_from_state(chat_state): memory = ConversationBufferWindowMemory( memory_key="chat_history", return_messages=True, k=5 ) for pair in chat_state or []: if len(pair) == 2: user_msg, ai_msg = pair memory.save_context({"input": user_msg}, {"output": ai_msg}) return memory def stream_response(user_input, user_id): if not user_id: user_id = "anonymous" # Do NOT reset memory here! Just generate response state = { "messages": [HumanMessage(content=user_message)], "user_id": user_id, } final_state = graph.invoke(state) final_message = final_state["messages"][-1].content collected = "" for token in final_message: collected += token yield collected def respond(user_message, chat_history, user_id, chat_state): lang_code = detect_supported_language(user_message) if not lang_code: chat_state = chat_state or [] chat_state.append([user_message, "Leider kann ich nur in den folgenden Sprachen lesen und schreiben: Deutsch, Englisch, Türkisch oder Arabisch. In welcher Sprache möchten Sie weitermachen?"]) return chat_state, chat_state, "" # clear textbox if not user_id: user_id = "anonymous" # Rebuild memory from chat_state memory = get_memory_from_state(chat_state) # Generate response state = { "messages": [HumanMessage(content=user_message)], "user_id": user_id, "chat_history": chat_state, } final_state = graph.invoke(state) full_response = final_state["messages"][-1].content # Save to memory (for next time) memory.save_context({"input": user_message}, {"output": full_response}) # Update chat_state chat_state = chat_state or [] chat_state.append([user_message, full_response]) return chat_state, chat_state, "" # clear textbox def clear_history(): return "", [], "" description = """ ### Was ist **Einbürgerungs-Helfer**? **Deutsch:** Einbürgerungs-Helfer hilft dir, den Weg zur deutschen Staatsangehörigkeit zu verstehen – einfach, mehrsprachig, datenschutzfreundlich. **English:** Einbürgerungs-Helfer helps you understand how to get German citizenship – simple, multilingual, and privacy-friendly. **Türkçe:** Einbürgerungs-Helfer, Almanya vatandaşlığına giden yolu anlamanıza yardımcı olur – basit, çok dilli ve gizliliğe saygılı.