Fix chatbot

.gitignore

@@ -0,0 +1,8 @@
+.venv/
+.env
+
+CLAUDE.md
+
+__pycache__/
+*.pyc
+.gradio/

app.py

@@ -1,48 +1,335 @@
+import base64
+import logging
+import mimetypes
+import os
+import re
+from pathlib import Path
+
 import gradio as gr
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+
 from bedrock_client import bedrock_llm
-from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
-import os
-from setuptools._distutils.util import strtobool
 
-MULTIMODAL = os.environ.get("MULTIMODAL", "false")
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+ERROR_MESSAGE = (
+    "⚠️ Bei der Verarbeitung deiner Nachricht ist ein Fehler aufgetreten. "
+    "Bitte versuche es erneut. Falls der Fehler bestehen bleibt, starte eine "
+    "neue Unterhaltung."
+)
+
+# Upload types Bedrock Converse accepts. Anything else is refused up front rather
+# than failing inside the model call. The model in MODEL_ID also has to support
+# them: claude-sonnet-4-6 handles both images and documents.
+SUPPORTED_IMAGES = {"image/png", "image/jpeg", "image/gif", "image/webp"}
+SUPPORTED_DOCUMENTS = {
+    "application/pdf",
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/vnd.ms-excel",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "text/csv",
+    "text/html",
+    "text/markdown",
+    "text/plain",
+}
+SUPPORTED_UPLOADS = SUPPORTED_IMAGES | SUPPORTED_DOCUMENTS
+
+# The extensions the upload button offers, mapped to the MIME type we send. Spelled
+# out rather than left to mimetypes, whose table varies with the interpreter the
+# Space builds; an extension the button offers but upload_block() then refuses
+# looks like a bug to the user. Every value must appear in SUPPORTED_UPLOADS.
+EXTENSION_MIME_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".pdf": "application/pdf",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".csv": "text/csv",
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".md": "text/markdown",
+    ".txt": "text/plain",
+}
+UPLOAD_FILE_TYPES = sorted(EXTENSION_MIME_TYPES)
+
+UPLOAD_ERROR = (
+    "⚠️ Diese Dateien kann ich nicht verarbeiten: {names}. Unterstützt werden "
+    "Bilder (PNG, JPEG, GIF, WebP) sowie PDF, DOC/DOCX, XLS/XLSX, CSV, HTML, "
+    "Markdown und Text."
+)
+
+# Shown to the model in place of an upload from an earlier turn
+FILE_PLACEHOLDER = "[Datei aus einer früheren Nachricht: {name}]"
+
+# Some models reject a turn that carries files but no text
+DEFAULT_UPLOAD_PROMPT = "Bitte werte die angehängten Dateien aus."
+
+# Bedrock allows only alphanumerics, whitespace, hyphens, parentheses and square
+# brackets in a document name, and no runs of whitespace
+UNSAFE_DOCUMENT_NAME = re.compile(r"[^A-Za-z0-9\s\-()\[\]]")
+
+TRUTHY = {"1", "true", "yes", "y", "on"}
+FALSY = {"0", "false", "no", "n", "off"}
+
+
+def env_bool(name, default="false"):
+    """Read a boolean environment variable, failing loudly on anything else.
+
+    An empty variable counts as unset, so a blank Space setting cannot crash
+    startup.
+    """
+    raw = (os.environ.get(name) or default).strip().lower()
+    if raw in TRUTHY:
+        return True
+    if raw in FALSY:
+        return False
+    raise ValueError(f"Invalid {name} value {raw!r}: use true/false, 1/0, yes/no.")
 
-# 1) convert common truthy/falsy strings to bool
-try:
-    MULTIMODAL = bool(strtobool(MULTIMODAL))
-except ValueError:
-    # catch unrecognized values
-    raise ValueError(f"Invalid MULTIMODAL value: Use true/false, 1/0, yes/no.")
 
-AUTHS = [(os.environ.get('USER'), os.environ.get('PW'))]
+# On by default now that MODEL_ID points at a model that can read the uploads
+MULTIMODAL = env_bool("MULTIMODAL", "true")
+
+# DEVALBOT_ prefixed so the shell's own USER variable cannot become the login
+DEVALBOT_USER = os.environ.get("DEVALBOT_USER")
+DEVALBOT_PW = os.environ.get("DEVALBOT_PW")
+if not DEVALBOT_USER or not DEVALBOT_PW:
+    raise RuntimeError(
+        "DEVALBOT_USER and DEVALBOT_PW must both be set; refusing to start with "
+        "incomplete credentials."
+    )
+AUTHS = [(DEVALBOT_USER, DEVALBOT_PW)]
 
 SYSTEM_PROMPT = os.environ.get('SYSTEM_PROMPT', '')
 
+# Every turn resends the whole conversation, so it has to stay inside the
+# model's context window. claude-sonnet-4-6 offers 1M tokens; at roughly 4
+# characters per token that is ~4M characters, so the window is not the binding
+# constraint here — cost and latency are, because each turn resends everything.
+# 500k characters (~125k tokens, an eighth of the window) buys a very long
+# conversation while keeping per-turn spend bounded. Raise it via the
+# environment if you would rather trade cost for a longer memory, and lower it
+# alongside MODEL_ID if you move to a smaller model.
+MAX_HISTORY_CHARS = int(os.environ.get("MAX_HISTORY_CHARS", "500000"))
+
+if len(SYSTEM_PROMPT) > MAX_HISTORY_CHARS // 2:
+    logger.warning(
+        "SYSTEM_PROMPT uses %d of the %d character budget, leaving little room "
+        "for the conversation", len(SYSTEM_PROMPT), MAX_HISTORY_CHARS,
+    )
+
+
+def exchanges(turns):
+    """Group a flat turn list into [user, assistant...] exchanges."""
+    grouped: list = []
+    for msg in turns:
+        if isinstance(msg, HumanMessage) or not grouped:
+            grouped.append([msg])
+        else:
+            grouped[-1].append(msg)
+    return grouped
+
+
+def trim_history(turns, budget):
+    """Keep the newest complete exchanges that fit into budget characters.
+
+    Trimming whole exchanges rather than individual messages keeps the result
+    well formed: Bedrock Converse rejects a conversation that does not start
+    with a user turn, and an assistant turn is worthless without the question
+    it answers.
+    """
+    kept: list = []
+    used = 0
+
+    for exchange in reversed(exchanges(turns)):
+        size = sum(len(str(msg.content)) for msg in exchange)
+        # always keep the newest exchange, even if it alone blows the budget
+        if kept and used + size > budget:
+            break
+        used += size
+        kept.insert(0, exchange)
+
+    flat = [msg for exchange in kept for msg in exchange]
+
+    # a history that somehow opens on an assistant turn would still be rejected
+    while flat and not isinstance(flat[0], HumanMessage):
+        flat.pop(0)
+
+    return flat
 
-def chat(message, history):
 
-    # 1) start with the system prompt
-    history_langchain_format: list = [SystemMessage(content=SYSTEM_PROMPT)]
+def document_name(path):
+    """Derive a Bedrock-safe document name from an upload's filename."""
+    cleaned = UNSAFE_DOCUMENT_NAME.sub(" ", Path(path).stem)
+    return re.sub(r"\s+", " ", cleaned).strip() or "Dokument"
 
-    # 2) replay the user/assistant turns
+
+def upload_mime_type(path):
+    """An upload's MIME type, preferring our own table over mimetypes."""
+    extension = Path(path).suffix.lower()
+    if extension in EXTENSION_MIME_TYPES:
+        return EXTENSION_MIME_TYPES[extension]
+    mime, _ = mimetypes.guess_type(path)
+    return mime
+
+
+def upload_block(path):
+    """Build a LangChain data content block for an upload, or None if unusable."""
+    mime = upload_mime_type(path)
+    if mime not in SUPPORTED_UPLOADS:
+        logger.warning("Refusing upload %s with MIME type %s", path, mime)
+        return None
+
+    try:
+        data = base64.b64encode(Path(path).read_bytes()).decode()
+    except OSError:
+        logger.exception("Could not read upload %s", path)
+        return None
+
+    # langchain_aws reads camelCase keys straight off the block
+    if mime in SUPPORTED_IMAGES:
+        return {"type": "image", "mimeType": mime, "base64": data}
+    return {
+        "type": "file",
+        "mimeType": mime,
+        "base64": data,
+        "name": document_name(path),
+    }
+
+
+def history_file_path(content):
+    """Pull the path out of a history entry that holds a file rather than text.
+
+    Gradio stores these either as a (path,) tuple or as a {"path": ...} dict.
+    """
+    if isinstance(content, (tuple, list)):
+        return str(content[0]) if content else None
+    if isinstance(content, dict):
+        return content.get("path")
+    return None
+
+
+def replay_history(history):
+    """Convert Gradio's history entries into LangChain messages."""
+    turns: list = []
     for msg in history:
+        content = msg.get("content")
+        if not isinstance(content, str):
+            # An upload from an earlier turn. Re-sending the bytes on every turn
+            # would grow the payload without bound, so reference it by name.
+            path = history_file_path(content)
+            if path is None:
+                logger.warning("Skipping history entry of type %s", type(content))
+                continue
+            content = FILE_PLACEHOLDER.format(name=Path(path).name)
+
         if msg["role"] == "user":
-            history_langchain_format.append(HumanMessage(content=msg["content"]))
+            turns.append(HumanMessage(content=content))
         elif msg["role"] == "assistant":
-            history_langchain_format.append(AIMessage(content=msg["content"]))
+            turns.append(AIMessage(content=content))
+    return turns
+
+
+def user_message(message):
+    """Build the new HumanMessage, plus the names of any refused uploads.
+
+    With multimodal=True Gradio passes a {"text", "files"} dict instead of a str.
+    """
+    if not isinstance(message, dict):
+        return HumanMessage(content=message), []
 
-    # 3) append the new user message
-    history_langchain_format.append(HumanMessage(content=message))
+    text = (message.get("text") or "").strip()
+    blocks: list = []
+    refused: list = []
+    for path in message.get("files") or []:
+        block = upload_block(path)
+        if block is None:
+            refused.append(Path(str(path)).name)
+        else:
+            blocks.append(block)
 
-    stream =bedrock_llm.stream(history_langchain_format)
+    if not blocks:
+        return HumanMessage(content=text), refused
 
-    full = next(stream)
+    blocks.append({"type": "text", "text": text or DEFAULT_UPLOAD_PROMPT})
+    return HumanMessage(content=blocks), refused
 
-    for chunk in stream:
-         full +=chunk
-         yield full.content
 
+def chunk_text(msg):
+    """Flatten a streamed message's content into plain text.
 
-with gr.Blocks(css_paths=["static/deval.css"],theme = gr.themes.Default(primary_hue="blue", secondary_hue="yellow"),) as demo:
+    ChatBedrockConverse streams content as a list of blocks
+    ([{"type": "text", "text": "...", "index": 0}]), not a string, and Gradio's
+    chatbot expects a string. Tool-use or other non-text blocks are ignored.
+    """
+    if isinstance(msg.content, str):
+        return msg.content
+    return "".join(
+        block.get("text", "")
+        for block in msg.content
+        if isinstance(block, dict)
+    )
+
+
+def chat(message, history):
+
+    # 1) replay the user/assistant turns
+    turns = replay_history(history)
+
+    # 2) append the new user message, refusing uploads we cannot send
+    new_message, refused = user_message(message)
+    if refused:
+        yield UPLOAD_ERROR.format(names=", ".join(refused))
+        return
+    turns.append(new_message)
+
+    # 3) drop the oldest turns, then prepend the system prompt. The prompt shares
+    #    the context window with the turns, so it has to come out of the budget.
+    kept = trim_history(turns, MAX_HISTORY_CHARS - len(SYSTEM_PROMPT))
+    if len(kept) < len(turns):
+        logger.info("Dropped %d of %d turns to stay within the context budget",
+                    len(turns) - len(kept), len(turns))
+
+    history_langchain_format: list = [SystemMessage(content=SYSTEM_PROMPT)] + kept
+
+    # 4) stream the answer; never let a backend error surface as a bare "Error"
+    text = ""
+    try:
+        # Do not pull the first chunk with next(): an empty stream raises
+        # StopIteration inside a generator (which Python turns into a
+        # RuntimeError), and a single-chunk stream never reaches the loop body
+        # and so yields nothing at all.
+        full = None
+        for chunk in bedrock_llm.stream(history_langchain_format):
+            full = chunk if full is None else full + chunk
+            text = chunk_text(full)
+            # the first chunk usually carries no text yet; do not blank the bubble
+            if text:
+                yield text
+
+        if not text:
+            logger.warning("Bedrock returned an empty stream")
+            yield ERROR_MESSAGE
+    except Exception:
+        # full traceback goes to the Space logs, the user gets a readable hint
+        logger.exception("Bedrock streaming failed after %d turns", len(history))
+        # keep whatever was already streamed instead of blanking the answer
+        yield f"{text}\n\n{ERROR_MESSAGE}" if text else ERROR_MESSAGE
+
+
+with gr.Blocks(
+    css_paths=["static/deval.css"],
+    theme=gr.themes.Default(primary_hue="blue", secondary_hue="yellow"),
+    # grow top-level children with scale >= 1 to the window height; the header row
+    # and the input group have no scale, so only the transcript stretches
+    fill_height=True,
+) as demo:
     # ── Logo + Header + Logout ────────────────────────────────
 
 
@@ -67,21 +354,30 @@ with gr.Blocks(css_paths=["static/deval.css"],theme = gr.themes.Default(primary_
                 "sowie sensible erhobene Daten (wie etwa Interviewtranskripte).", elem_id="header-text"
             )
 
-    # inject auto-reload script
-    gr.HTML(
-        """
-        <script>
-          // Reload the page after 1 minutes (300 000 ms)
-          setTimeout(() => {
-            window.location.reload();
-          }, 1000);
-        </script>
-        """
-    )
+    # Gradio's default MultimodalTextbox takes a single file of any type, which
+    # then gets refused by upload_block(). Offer several files and only the types
+    # we can actually forward.
+    upload_textbox = gr.MultimodalTextbox(
+        file_count="multiple",
+        file_types=UPLOAD_FILE_TYPES,
+        placeholder="Frage stellen oder Dateien anhängen …",
+    ) if MULTIMODAL else None
+
     gr.ChatInterface(
         chat,
         type="messages",
         multimodal=MULTIMODAL,
+        textbox=upload_textbox,
+        # ChatInterface would otherwise label the transcript "Chatbot". scale=1 is
+        # what makes fill_height stretch it: 400px is the floor it grows from, so
+        # the transcript takes the window height left over by header and input.
+        chatbot=gr.Chatbot(
+            type="messages",
+            show_label=False,
+            scale=1,
+            height=400,
+            elem_id="chat-window",
+        ),
         editable=True,
         concurrency_limit=20,
         save_history=True,
@@ -89,4 +385,4 @@ with gr.Blocks(css_paths=["static/deval.css"],theme = gr.themes.Default(primary_
     
 
 
-demo.queue().launch(auth=AUTHS, share=True, ssr_mode=False)
+demo.queue().launch(auth=AUTHS, ssr_mode=False, show_api=False)

bedrock_client.py

@@ -1,7 +1,5 @@
 import os
-from anthropic import AnthropicBedrock
 from langchain_aws.chat_models import ChatBedrockConverse
-from langchain_aws.llms.bedrock import BedrockLLM
 
 
 # Initialize the streaming Bedrock chat model
@@ -9,9 +7,10 @@ bedrock_llm = ChatBedrockConverse(
     aws_access_key_id       = os.environ.get("AWS_ACCESS_KEY_ID"),
     aws_secret_access_key   = os.environ.get("AWS_SECRET_ACCESS_KEY"),
     region_name             = os.environ.get("AWS_DEFAULT_REGION", "eu-west-1"),
-    provider                = os.environ.get("PROVIDER", "mistral"),
-    model_id                = os.environ.get("MODEL_ID", "mistral.mistral-large-2402-v1:0"),  # or your preferred Bedrock model
-    temperature             = eval(os.environ.get("TEMPERATURE", "0.7"))
+    provider                = os.environ.get("PROVIDER", "anthropic"),
+    # eu. prefix selects the EU cross-region inference profile
+    model_id                = os.environ.get("MODEL_ID", "eu.anthropic.claude-sonnet-4-6"),
+    temperature             = float(os.environ.get("TEMPERATURE", "0.7"))
     )
 
 

requirements.txt

@@ -1,12 +1,8 @@
-gradio>=4.20.0
-boto3>=1.34.0
-botocore
-fastapi
-uvicorn
-aiofiles
-anthropic[bedrock]>=0.50.0
-langchain-core
-langchain
-langchain-aws>=0.2.17
-langchain-community>=0.3.26
-setuptools
+# Pinned exactly: the Space rebuilds from this file, so an unpinned floor lets a
+# new major release break the deployment with no commit to point at. gradio has
+# to stay in step with sdk_version in README.md.
+# Only direct imports are listed here. boto3/botocore arrive with langchain-aws,
+# and fastapi/uvicorn/aiofiles with gradio.
+gradio==5.34.2
+langchain-core==1.5.3
+langchain-aws==1.6.4

static/deval.css

@@ -52,4 +52,12 @@ button.gr-button:hover {
 #header-text b,
 #header-text em {
   color: #C1CDDF !important;
+}
+
+/* ── Hide the Gradio footer ────────────────────────────────── */
+/* "Built with Gradio" and the "Use via API" link. launch(show_api=False)
+   drops the API entry; this removes the footer altogether. */
+footer,
+.gradio-container footer {
+  display: none !important;
 }

utils.py

@@ -1,10 +0,0 @@
-import csv
-
-def load_users(path):
-    """
-    Reads a CSV with header 'users,passwords'
-    and returns a list of (user, password) tuples.
-    """
-    with open(path, newline="", encoding="utf-8") as f:
-        reader = csv.DictReader(f)
-        return [(row["users"], row["passwords"]) for row in reader]