NatStudy / app.py
rvdbra's picture
Update app.py
6b31ee3 verified
Raw History Blame Contribute Delete
14.7 kB
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ı.
<div dir="rtl" style="text-align: right;"><strong>العربية:</strong> يساعدك مساعد التجنيس على فهم الطريق إلى الجنسية الألمانية - بسيط ومتعدد اللغات وملائم لحماية البيانات‪.‬</div>
"""
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")
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.\n"
"Sie können Ihre Frage auf Deutsch, Englisch, Türkisch oder Arabisch stellen.\n"
"Lassen Sie uns loslegen – wie kann ich Ihnen heute helfen?"]]
)
msg_input = gr.Textbox(
placeholder="Frage eingeben...",
label="Deine Nachricht",
lines=1,
value="" # start empty
)
with gr.Row():
submit_btn = gr.Button("Senden", variant="primary")
# Button click
submit_btn.click(
fn=respond,
inputs=[msg_input, chatbot, user_id_input, chat_state],
outputs=[chatbot, chat_state, msg_input],
)
# Enter key in textbox
msg_input.submit(
fn=respond,
inputs=[msg_input, chatbot, user_id_input, chat_state],
outputs=[chatbot, chat_state, msg_input],
)
clear_btn.click(fn=clear_history, inputs=[], outputs=[user_id_input, chatbot, msg_input])
iface.launch(share=True)