ui design

app.py

@@ -1,510 +1,29 @@
 import os
-import json
-from pathlib import Path
-from datetime import datetime
 
 import gradio as gr
 
-# FastAPI backend (mounted under /)
 from api import fastapi_app
+from ui_chat import UI_STYLE, build_chat_tab
+from ui_creator import build_creator_tab
+from ui_info import build_info_tab
 
-# Avatar logic
-from avatar_store import avatar_generated_path
-from generate_image_with_nano import build_prompt, run_edit
-from mcp_tools import (
-    create_avatar,
-    delete_avatar_memory,
-    delete_avatar_portrait,
-    delete_generated_images,
-    generate_as_avatar,
-    get_avatar,
-    record_generated_image,
-    set_avatar_portrait,
-    store_avatar_memory,
-)
-
-DEFAULT_AVATAR_ID = "08a2fb96"
-INITIAL_GREETING = "Hello! How are you doing?"
-
-
-# ----------------------------------------------------
-# Helpers
-# ----------------------------------------------------
-
-def _resolve_path(path_str):
-    if not path_str:
-        return None
-    path = Path(path_str)
-    if not path.is_absolute():
-        path = Path(__file__).parent / path
-    return str(path)
-
-
-def decide_tool(message: str) -> str:
-    text = (message or "").lower()
-    if "remember" in text:
-        return "store_avatar_memory"
-    if "who are you" in text:
-        return "get_avatar"
-    return "generate_as_avatar"
-
-
-# ----------------------------------------------------
-# Creator UI actions
-# ----------------------------------------------------
-
-def ui_create_avatar(description: str) -> str:
-    try:
-        data = create_avatar({"description": description})
-        return json.dumps(data, ensure_ascii=False)
-    except ValueError as exc:
-        return str(exc)
-
-
-def ui_load_avatar(avatar_id: str, admin_id: str):
-    try:
-        data = get_avatar({"avatar_id": avatar_id, "admin_id": admin_id})
-        data.pop("generated_images", None)
-        mem = data.get("memory", [])
-        rows = [[m.get("entry", ""), m.get("private", False)] for m in mem]
-        portrait = _resolve_path(data.get("portrait"))
-        return (
-            json.dumps(
-                {k: v for k, v in data.items() if k != "memory"},
-                ensure_ascii=False,
-                indent=2,
-            ),
-            rows,
-            [],
-            portrait,
-        )
-    except ValueError as exc:
-        return str(exc), [], [], None
-
-
-def ui_add_context_text(avatar_id: str, admin_id: str, text: str, private: bool):
-    text = (text or "").strip()
-    if not text:
-        return "Enter context text."
-    try:
-        store_avatar_memory(
-            {
-                "avatar_id": avatar_id,
-                "admin_id": admin_id,
-                "entry": text,
-                "private": private,
-            }
-        )
-        return "Context stored."
-    except ValueError as exc:
-        return str(exc)
-
-
-def ui_add_context_file(avatar_id: str, admin_id: str, file_obj, private: bool):
-    if not file_obj:
-        return "Upload a file."
-    try:
-        with open(file_obj.name, "r", encoding="utf-8") as handle:
-            data = handle.read(4000)
-    except Exception:
-        return "Unable to read file."
-    return ui_add_context_text(avatar_id, admin_id, data, private)
-
-
-def ui_delete_memory(avatar_id: str, admin_id: str, indices):
-    indices = indices or []
-    if isinstance(indices, (int, float)):
-        indices = [int(indices)]
-
-    if not indices:
-        return "Select entries to delete.", gr.update(), []
-
-    try:
-        for idx in sorted(set(int(i) for i in indices if int(i) >= 0), reverse=True):
-            delete_avatar_memory(
-                {"avatar_id": avatar_id, "admin_id": admin_id, "index": idx}
-            )
-        data = get_avatar({"avatar_id": avatar_id, "admin_id": admin_id})
-        mem = data.get("memory", [])
-        rows = [[m.get("entry", ""), m.get("private", False)] for m in mem]
-        return ("Entries removed.", rows, [])
-    except ValueError as exc:
-        return str(exc), gr.update(), indices
-
-
-def ui_upload_portrait(avatar_id: str, admin_id: str, file_path):
-    portrait_path = file_path.name if hasattr(file_path, "name") else file_path
-    if not portrait_path:
-        return "Upload a portrait image.", None
-    try:
-        result = set_avatar_portrait(
-            {
-                "avatar_id": avatar_id,
-                "admin_id": admin_id,
-                "portrait_file": portrait_path,
-            }
-        )
-        return "Portrait updated.", _resolve_path(result.get("portrait"))
-    except ValueError as exc:
-        return str(exc), None
-
-
-def ui_remove_portrait(avatar_id: str, admin_id: str):
-    try:
-        delete_avatar_portrait({"avatar_id": avatar_id, "admin_id": admin_id})
-        return "Portrait removed.", None
-    except ValueError as exc:
-        return str(exc), None
-
-
-def ui_clear_generated(avatar_id: str, admin_id: str):
-    try:
-        result = delete_generated_images({"avatar_id": avatar_id, "admin_id": admin_id})
-        return f"Removed {result.get('removed', 0)} generated images."
-    except ValueError as exc:
-        return str(exc)
-
-
-def ui_chat_portrait(avatar_id: str):
-    if not avatar_id:
-        return None
-    try:
-        data = get_avatar({"avatar_id": avatar_id, "admin_id": ""})
-        return _resolve_path(data.get("portrait"))
-    except ValueError:
-        return None
-
-
-def ui_select_memory(evt: gr.SelectData, current):
-    current = list(current or [])
-    if not evt or evt.index is None:
-        return current
-
-    idx = evt.index
-    if isinstance(idx, (list, tuple)):
-        idx = idx[0]
-    if idx is None:
-        return current
-
-    row = int(idx)
-    if row in current:
-        current.remove(row)
-    else:
-        current.append(row)
-    return current
-
-
-# ----------------------------------------------------
-# Chat logic
-# ----------------------------------------------------
-
-def _format_history(history):
-    return [
-        {"role": "user" if speaker == "user" else "assistant", "content": content}
-        for speaker, content in history
-    ]
-
-
-def send_message(avatar_id, admin_id, message, history, generate_image=True):
-    history = history or []
-    message = (message or "").strip()
-    tool = ""
-    image_path = None
-
-    if not message:
-        return _format_history(history), "", history, tool, image_path, generate_image
-
-    if not avatar_id:
-        history.append(("avatar", "Set avatar id first."))
-        return _format_history(history), "", history, tool, image_path, generate_image
-
-    history.append(("user", message))
-    tool = decide_tool(message)
-
-    try:
-        if tool == "store_avatar_memory":
-            if not admin_id:
-                reply = "Admin id required to store memory."
-            else:
-                result = store_avatar_memory(
-                    {
-                        "avatar_id": avatar_id,
-                        "admin_id": admin_id,
-                        "entry": message,
-                        "private": True,
-                    }
-                )
-                reply = f"Memory stored ({result['memory_entries']})."
-
-        elif tool == "get_avatar":
-            data = get_avatar({"avatar_id": avatar_id, "admin_id": admin_id})
-            image_path = _resolve_path(data.get("portrait"))
-            reply = json.dumps(data, ensure_ascii=False)
-
-        else:
-            data = generate_as_avatar(
-                {"avatar_id": avatar_id, "message": message, "history": history}
-            )
-            reply = data["response"]
-
-            avatar = get_avatar({"avatar_id": avatar_id, "admin_id": admin_id})
-            image_path = _resolve_path(avatar.get("portrait"))
-
-            if not image_path:
-                generate_image = False
-
-    except ValueError as exc:
-        reply = str(exc)
-
-    history.append(("avatar", reply))
-    image_output = gr.update()
-    return (
-        _format_history(history),
-        "",
-        history,
-        f"Tool used: {tool or 'n/a'}",
-        image_output,
-        generate_image,
-    )
-
-
-def send_message_public(avatar_id, message, history, generate_image=True):
-    return send_message(avatar_id, "", message, history, generate_image)
-
-
-def initial_greeting(avatar_id):
-    avatar_id = avatar_id or DEFAULT_AVATAR_ID
-    return send_message_public(avatar_id, INITIAL_GREETING, [], True)
-
-
-def maybe_generate_image(avatar_id, history, generate_image=True, current_image=None):
-    current_image = current_image or None
-    if not generate_image:
-        return current_image, generate_image
-    if not avatar_id:
-        return current_image, generate_image
-    if not history:
-        return current_image, generate_image
-
-    last_user = None
-    last_reply = None
-    for speaker, content in reversed(history):
-        if last_reply is None and speaker == "avatar":
-            last_reply = content
-        elif last_user is None and speaker == "user":
-            last_user = content
-        if last_user and last_reply:
-            break
-
-    try:
-        avatar = get_avatar({"avatar_id": avatar_id, "admin_id": ""})
-    except ValueError:
-        return current_image, False
-
-    portrait_path = _resolve_path(avatar.get("portrait"))
-    if not portrait_path or not Path(portrait_path).exists():
-        return current_image, False
-
-    try:
-        prompt = build_prompt(
-            avatar.get("persona", "Avatar"),
-            f"{last_user or ''} Reply: {last_reply or ''}",
-        )
-        timestamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
-        out_path = avatar_generated_path(avatar_id, timestamp)
-        out_path.parent.mkdir(parents=True, exist_ok=True)
-
-        rc = run_edit(Path(portrait_path), prompt, out_path)
-        if rc == 0:
-            record_generated_image(avatar_id, out_path, prompt, timestamp)
-            return str(out_path), True
-    except BaseException:
-        return current_image, generate_image
-
-    return current_image, generate_image
-
-
-# ----------------------------------------------------
-# UI Assembly
-# ----------------------------------------------------
 
 with gr.Blocks() as ui:
-    gr.Markdown("## Avatar Persona MCP")
+    gr.HTML(UI_STYLE, sanitize_html=False)
+    gr.Markdown("## Avatar MCP")
 
-    # Chat tab
-    with gr.Tab("Chat"):
-        gr.Markdown("Enter an avatar ID to chat with the public persona.")
+    with gr.Tabs():
+        build_chat_tab(ui)
+        build_creator_tab()
+        build_info_tab()
 
-        avatar_id_input = gr.Textbox(
-            label="Avatar ID",
-            placeholder="e.g. 08a2fb96",
-            value=DEFAULT_AVATAR_ID,
-        )
-        image_display = gr.Image(label="Image", type="filepath")
-        generate_toggle = gr.Checkbox(label="Generate image for this reply", value=True)
-        chat = gr.Chatbot()
-        msg = gr.Textbox(label="Message")
-        state = gr.State([])
-        send_btn = gr.Button("Send")
-        clear_btn = gr.Button("Clear Chat")
-        tool_status = gr.Markdown("Tool used: n/a")
-
-        chat_event = msg.submit(
-            send_message_public,
-            inputs=[avatar_id_input, msg, state, generate_toggle],
-            outputs=[chat, msg, state, tool_status, image_display, generate_toggle],
-        )
-        chat_event.then(
-            maybe_generate_image,
-            inputs=[avatar_id_input, state, generate_toggle, image_display],
-            outputs=[image_display, generate_toggle],
-        )
-
-        send_event = send_btn.click(
-            send_message_public,
-            inputs=[avatar_id_input, msg, state, generate_toggle],
-            outputs=[chat, msg, state, tool_status, image_display, generate_toggle],
-        )
-        send_event.then(
-            maybe_generate_image,
-            inputs=[avatar_id_input, state, generate_toggle, image_display],
-            outputs=[image_display, generate_toggle],
-        )
-
-        clear_btn.click(
-            lambda: ([], "", [], "Tool used: n/a", None, True),
-            outputs=[chat, msg, state, tool_status, image_display, generate_toggle],
-        )
-
-        avatar_id_input.change(ui_chat_portrait, inputs=avatar_id_input, outputs=image_display)
-
-        initial_load = ui.load(
-            initial_greeting,
-            inputs=[avatar_id_input],
-            outputs=[chat, msg, state, tool_status, image_display, generate_toggle],
-        )
-        initial_load.then(
-            maybe_generate_image,
-            inputs=[avatar_id_input, state, generate_toggle, image_display],
-            outputs=[image_display, generate_toggle],
-        )
-
-    # Creator tab
-    with gr.Tab("Creator"):
-        gr.Markdown("Create avatars, upload portraits, and manage memory.")
-
-        with gr.Row():
-            with gr.Column():
-                description = gr.Textbox(label="Description")
-                create_btn = gr.Button("Create")
-                create_output = gr.Textbox(label="Result", lines=3)
-                create_btn.click(ui_create_avatar, inputs=description, outputs=create_output)
-
-            with gr.Column():
-                creator_avatar_id = gr.Textbox(label="Avatar ID", value="08a2fb96")
-                creator_admin_id = gr.Textbox(
-                    label="Admin ID",
-                    type="password",
-                    value="01043e7a9c7141f892d0b08e6c325f18",
-                )
-                load_btn = gr.Button("Load")
-                avatar_data = gr.Textbox(label="Avatar Data", lines=6)
-                portrait_view = gr.Image(label="Portrait", type="filepath")
-                memory_table = gr.Dataframe(
-                    headers=["memory", "private"],
-                    wrap=True,
-                    interactive=True,
-                    show_row_numbers=True,
-                )
-                selected_index = gr.State([])
-
-                memory_table.select(ui_select_memory, inputs=[selected_index], outputs=[selected_index])
-
-                load_btn.click(
-                    ui_load_avatar,
-                    inputs=[creator_avatar_id, creator_admin_id],
-                    outputs=[avatar_data, memory_table, selected_index, portrait_view],
-                )
-
-                delete_btn = gr.Button("Remove Selected Memories")
-                delete_status = gr.Textbox(label="Delete Status", lines=2)
-                delete_btn.click(
-                    ui_delete_memory,
-                    inputs=[creator_avatar_id, creator_admin_id, selected_index],
-                    outputs=[delete_status, memory_table, selected_index],
-                )
-
-                portrait_upload = gr.Image(label="Upload New Portrait", type="filepath")
-                portrait_status = gr.Textbox(label="Portrait Status", lines=2)
-                upload_portrait_btn = gr.Button("Save Portrait")
-                remove_portrait_btn = gr.Button("Remove Portrait")
-                clear_generated_btn = gr.Button("Remove Generated Images")
-                clear_generated_status = gr.Textbox(label="Generated Images Status", lines=2)
-
-                upload_portrait_btn.click(
-                    ui_upload_portrait,
-                    inputs=[creator_avatar_id, creator_admin_id, portrait_upload],
-                    outputs=[portrait_status, portrait_view],
-                )
-                remove_portrait_btn.click(
-                    ui_remove_portrait,
-                    inputs=[creator_avatar_id, creator_admin_id],
-                    outputs=[portrait_status, portrait_view],
-                )
-                clear_generated_btn.click(
-                    ui_clear_generated,
-                    inputs=[creator_avatar_id, creator_admin_id],
-                    outputs=[clear_generated_status],
-                )
-
-        gr.Markdown("### Add Context")
-        context_text = gr.Textbox(label="Context Text or URL", lines=4)
-        private_toggle = gr.Checkbox(label="Private?", value=False)
-        add_text_btn = gr.Button("Add Text Context")
-        text_status = gr.Textbox(label="Status", lines=2)
-
-        add_text_btn.click(
-            ui_add_context_text,
-            inputs=[creator_avatar_id, creator_admin_id, context_text, private_toggle],
-            outputs=text_status,
-        )
-
-        context_file = gr.File(label="Text File")
-        add_file_btn = gr.Button("Add File Context")
-        file_status = gr.Textbox(label="File Status", lines=2)
-
-        add_file_btn.click(
-            ui_add_context_file,
-            inputs=[creator_avatar_id, creator_admin_id, context_file, private_toggle],
-            outputs=file_status,
-        )
-
-    with gr.Tab("Info"):
-        gr.Markdown("### Avatar MCP Workflow")
-        gr.Image(
-            label="Infographic",
-            value=_resolve_path("avatar_infographic.png"),
-            type="filepath",
-        )
-
-# ----------------------------------------------------
-# Export ASGI app for Hugging Face Spaces
-# ----------------------------------------------------
-# Mount Gradio UI at "/" so FastAPI lives at /mcp/*
-# ----------------------------------------------------
 
 app = gr.mount_gradio_app(fastapi_app, ui, path="/")
 
-# ----------------------------------------------------
-# Local-only server runner
-# ----------------------------------------------------
-# HuggingFace Spaces sets SPACE_ID → DO NOT run uvicorn here.
-# Dockerfile CMD will run uvicorn in HF.
-# Local Python execution ("python app.py") WILL run uvicorn.
-# ----------------------------------------------------
 
 if __name__ == "__main__" and not os.getenv("SPACE_ID"):
     import uvicorn
+
     port = int(os.getenv("PORT", "7860"))
-    print(f"Starting local uvicorn on {port}...")
+    print(f"Running locally at http://localhost:{port}")
     uvicorn.run(app, host="0.0.0.0", port=port)

logic.py

@@ -0,0 +1,419 @@
+# logic.py
+# Modernized backend logic for Avatar MCP
+# Contains ALL non-UI logic: chat, creator tools, images, helpers.
+# UI lives in app.py and calls these functions.
+
+import json
+import base64
+import html
+import re
+import string
+from pathlib import Path
+from datetime import datetime
+
+# FastAPI + Avatar backend imports
+from mcp_tools import (
+    create_avatar,
+    delete_avatar_portrait,
+    delete_generated_images,
+    generate_as_avatar,
+    get_avatar,
+    record_generated_image,
+    set_avatar_portrait,
+    store_avatar_memory,
+    save_all_memories,
+    ensure_avatar_by_admin,
+)
+from avatar_store import avatar_generated_path
+from generate_image_with_nano import build_prompt, run_edit
+from persona_engine import extract_memories_from_text
+
+
+DEFAULT_AVATAR_ID = "08a2fb96"
+INITIAL_GREETING = "Hello! How are you doing?"
+
+
+# =====================================================
+# Helpers
+# =====================================================
+
+def resolve_path(path_str):
+    if not path_str:
+        return None
+    p = Path(path_str)
+    if not p.is_absolute():
+        p = Path(__file__).parent / p
+    return str(p)
+
+
+def encode_image_data(path_str):
+    """Convert image file → base64 data URL."""
+    try:
+        data = Path(path_str).read_bytes()
+        b64 = base64.b64encode(data).decode("utf-8")
+        ext = Path(path_str).suffix.lower()
+        mime = {
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".png": "image/png",
+            ".gif": "image/gif",
+            ".webp": "image/webp",
+        }.get(ext, "image/png")
+        return f"data:{mime};base64,{b64}"
+    except Exception:
+        return ""
+
+
+def history_pairs(history):
+    """Convert internal dict history → MCP-friendly tuples."""
+    out = []
+    for entry in history or []:
+        s = entry.get("speaker")
+        if s not in ("user", "avatar"):
+            s = "avatar"
+        out.append((s, entry.get("text", "")))
+    return out
+
+
+def decide_tool(message: str) -> str:
+    text = (message or "").lower()
+    if "remember" in text:
+        return "store_avatar_memory"
+    if "who are you" in text:
+        return "get_avatar"
+    return "generate_as_avatar"
+
+
+def _ensure_avatar_id(avatar_id: str, admin_id: str) -> str:
+    if avatar_id:
+        return avatar_id
+    if not admin_id:
+        raise ValueError("avatar_id or admin_id required")
+    avatar = ensure_avatar_by_admin(admin_id)
+    if not avatar:
+        raise ValueError("avatar not found for admin id")
+    return avatar.get("id")
+
+
+# =====================================================
+# Chat Logic
+# =====================================================
+
+def send_message(avatar_id, admin_id, message, history, generate_image=True):
+    """
+    Core chat pipeline:
+    - append user message
+    - choose tool
+    - execute tool
+    - append avatar reply
+    """
+    history = list(history or [])
+    msg = (message or "").strip()
+    tool = ""
+
+    if not msg:
+        return history, "n/a"
+
+    # Append user message
+    history.append({"speaker": "user", "text": msg})
+    tool = decide_tool(msg)
+
+    try:
+        if tool == "store_avatar_memory":
+            if not admin_id:
+                reply = "Admin id required to store memory."
+            else:
+                result = store_avatar_memory({
+                    "avatar_id": avatar_id,
+                    "admin_id": admin_id,
+                    "entry": msg,
+                    "private": True
+                })
+                reply = f"Memory stored ({result['memory_entries']})."
+
+        elif tool == "get_avatar":
+            data = get_avatar({"avatar_id": avatar_id, "admin_id": admin_id})
+            reply = json.dumps(data, ensure_ascii=False)
+
+        else:
+            # Persona reply
+            data = generate_as_avatar({
+                "avatar_id": avatar_id,
+                "message": msg,
+                "history": history_pairs(history)
+            })
+            reply = data["response"]
+
+            # Check portrait availability before generating images
+            avatar = get_avatar({"avatar_id": avatar_id, "admin_id": admin_id})
+            portrait = resolve_path(avatar.get("portrait"))
+            if not portrait:
+                generate_image = False
+
+    except ValueError as exc:
+        reply = str(exc)
+
+    # Add avatar reply
+    history.append({"speaker": "avatar", "text": reply})
+
+    return history, tool
+
+
+def send_message_public(avatar_id, message, history, generate_image=True):
+    """Public chat mode = no admin id."""
+    return send_message(avatar_id, "", message, history, generate_image)
+
+
+def initial_greeting(avatar_id):
+    avatar_id = avatar_id or DEFAULT_AVATAR_ID
+    history, _ = send_message_public(avatar_id, INITIAL_GREETING, [], True)
+    return history
+
+
+def maybe_generate_image(avatar_id, history, generate_image=True):
+    """
+    After the avatar replies, decide whether to generate an image.
+    """
+    history = list(history or [])
+
+    if not generate_image or not avatar_id or not history:
+        return history
+
+    # Find last avatar message + user message
+    last_user = None
+    last_avatar = None
+    for entry in reversed(history):
+        if entry.get("speaker") == "avatar" and last_avatar is None:
+            last_avatar = entry
+        elif entry.get("speaker") == "user" and last_user is None:
+            last_user = entry.get("text", "")
+        if last_avatar and last_user:
+            break
+
+    if not last_avatar:
+        return history
+
+    # Check portrait
+    try:
+        avatar = get_avatar({"avatar_id": avatar_id, "admin_id": ""})
+    except ValueError:
+        return history
+
+    portrait = resolve_path(avatar.get("portrait"))
+    if not portrait or not Path(portrait).exists():
+        return history
+
+    # Build prompt for the image generator
+    try:
+        prompt = build_prompt(
+            avatar.get("persona", "Avatar"),
+            f"{last_user or ''} Reply: {last_avatar.get('text', '')}"
+        )
+        timestamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
+        out_path = avatar_generated_path(avatar_id, timestamp)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+
+        rc = run_edit(Path(portrait), prompt, out_path)
+        if rc == 0:
+            record_generated_image(avatar_id, out_path, prompt, timestamp)
+            last_avatar["image_path"] = str(out_path)
+            last_avatar["image_data"] = encode_image_data(out_path)
+    except BaseException:
+        pass
+
+    return history
+
+
+def clear_chat_session():
+    """Reset chat state."""
+    return [], "Tool used: n/a", True
+
+
+# =====================================================
+# Creator Logic
+# =====================================================
+
+def ui_create_avatar(description: str):
+    try:
+        data = create_avatar({"description": description})
+        avatar_id = data.get("id")
+        admin_id = data.get("admin_id")
+        json_blob, rows, portrait, _, _, _ = ui_load_avatar(avatar_id, admin_id)
+        return f"Avatar created: {avatar_id}", json_blob, rows, portrait, avatar_id, admin_id
+    except ValueError as exc:
+        return str(exc), "", [], None, "", ""
+
+
+def ui_load_avatar(avatar_id: str, admin_id: str):
+    """Load avatar + memory + portrait."""
+    try:
+        if avatar_id:
+            data = get_avatar({"avatar_id": avatar_id, "admin_id": admin_id})
+        else:
+            data = ensure_avatar_by_admin(admin_id)
+            avatar_id = data.get("id")
+            admin_id = data.get("admin_id", admin_id)
+        data = dict(data)
+        data.pop("generated_images", None)
+
+        mem = data.get("memory", [])
+        rows = [[m.get("entry", ""), m.get("private", False)] for m in mem]
+        portrait = resolve_path(data.get("portrait"))
+
+        return (
+            json.dumps({k: v for k, v in data.items() if k != "memory"},
+                       ensure_ascii=False, indent=2),
+            rows,
+            portrait,
+            "Avatar loaded.",
+            avatar_id,
+            admin_id,
+        )
+    except ValueError as exc:
+        return str(exc), [], None, str(exc), "", ""
+
+
+def _current_memory_rows(avatar_id: str, admin_id: str):
+    try:
+        avatar_id = _ensure_avatar_id(avatar_id, admin_id)
+        data = get_avatar({"avatar_id": avatar_id, "admin_id": admin_id})
+    except ValueError:
+        return []
+    mem = data.get("memory", [])
+    return [[m.get("entry", ""), m.get("private", False)] for m in mem]
+
+
+def _clean_memory_entry(text: str) -> str:
+    raw = (text or "").strip()
+    raw = re.sub(r"^```[\w-]*", "", raw, flags=re.IGNORECASE).strip()
+    raw = raw.replace("```", " ")
+    raw = raw.replace('"', "")
+    raw = " ".join(raw.split())
+    allowed = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 .,!?'-")
+    clean = "".join(ch for ch in raw if ch in allowed).strip()
+    return clean
+
+
+def _ingest_memories(avatar_id: str, admin_id: str, text: str, private: bool):
+    avatar_id = _ensure_avatar_id(avatar_id, admin_id)
+    entries = extract_memories_from_text(text, max_items=200) or [text]
+    stored = 0
+    for entry in entries:
+        clean = _clean_memory_entry(entry)
+        if not clean:
+            continue
+        store_avatar_memory({
+            "avatar_id": avatar_id,
+            "admin_id": admin_id,
+            "entry": clean,
+            "private": private
+        })
+        stored += 1
+    rows = _current_memory_rows(avatar_id, admin_id)
+    if stored == 0:
+        return "No memories extracted.", rows
+    if stored == 1:
+        return "Stored 1 memory.", rows
+    return f"Stored {stored} memories.", rows
+
+
+def ui_add_context_text(avatar_id: str, admin_id: str, text: str, private: bool):
+    text = (text or "").strip()
+    if not text:
+        return "Enter context text.", _current_memory_rows(avatar_id, admin_id)
+    try:
+        return _ingest_memories(avatar_id, admin_id, text, private)
+    except ValueError as exc:
+        return str(exc), _current_memory_rows(avatar_id, admin_id)
+
+
+def ui_add_context_file(avatar_id: str, admin_id: str, file_obj, private: bool):
+    if not file_obj:
+        return "Upload a file.", _current_memory_rows(avatar_id, admin_id)
+    try:
+        with open(file_obj.name, "r", encoding="utf-8") as f:
+            data = f.read()
+        return ui_add_context_text(avatar_id, admin_id, data, private)
+    except Exception as exc:
+        return f"Unable to read file: {exc}", _current_memory_rows(avatar_id, admin_id)
+
+
+def ui_upload_portrait(avatar_id: str, admin_id: str, file_path):
+    portrait_path = file_path.name if hasattr(file_path, "name") else file_path
+    if not portrait_path:
+        return "Upload a portrait image.", None
+    try:
+        avatar_id = _ensure_avatar_id(avatar_id, admin_id)
+        result = set_avatar_portrait({
+            "avatar_id": avatar_id,
+            "admin_id": admin_id,
+            "portrait_file": portrait_path
+        })
+        return "Portrait updated.", resolve_path(result.get("portrait"))
+    except ValueError as exc:
+        return str(exc), None
+
+
+def ui_remove_portrait(avatar_id: str, admin_id: str):
+    try:
+        avatar_id = _ensure_avatar_id(avatar_id, admin_id)
+        delete_avatar_portrait({"avatar_id": avatar_id, "admin_id": admin_id})
+        return "Portrait removed.", None
+    except ValueError as exc:
+        return str(exc), None
+
+
+def ui_clear_generated(avatar_id: str, admin_id: str):
+    try:
+        avatar_id = _ensure_avatar_id(avatar_id, admin_id)
+        result = delete_generated_images({"avatar_id": avatar_id, "admin_id": admin_id})
+        return f"Removed {result.get('removed', 0)} generated images."
+    except ValueError as exc:
+        return str(exc)
+
+
+def ui_chat_portrait(avatar_id: str):
+    if not avatar_id:
+        return None
+    try:
+        data = get_avatar({"avatar_id": avatar_id, "admin_id": ""})
+        return resolve_path(data.get("portrait"))
+    except ValueError:
+        return None
+
+
+def ui_select_memory(evt=None, current=None):
+    """Toggle row selection in memory table."""
+    current = list(current or [])
+    if not evt or getattr(evt, "index", None) is None:
+        return current
+
+    idx = evt.index
+    if isinstance(idx, (list, tuple)):
+        idx = idx[0]
+    if idx is None:
+        return current
+
+    row = int(idx)
+    if row in current:
+        current.remove(row)
+    else:
+        current.append(row)
+    return current
+
+def ui_update_memory(avatar_id, admin_id, updated_table):
+    """
+    updated_table is a list of rows like:
+    [
+        ["text of memory", True],
+        ["another memory", False],
+    ]
+    """
+    try:
+        avatar_id = _ensure_avatar_id(avatar_id, admin_id)
+        if hasattr(updated_table, "to_numpy"):
+            updated_table = updated_table.to_numpy().tolist()
+        result = save_all_memories(avatar_id, admin_id, updated_table)
+        return "Memories updated successfully!"
+    except ValueError as exc:
+        return str(exc)

mcp_tools.py

@@ -4,6 +4,7 @@ from typing import Any, Dict
 
 from avatar_store import (
     ROOT as AVATAR_ROOT,
+    STORE,
     avatar_portrait_path,
     avatar_generated_path,
     avatar_generated_dir,
@@ -89,6 +90,33 @@ def store_avatar_memory(payload: Dict[str, Any]) -> Dict[str, Any]:
     return {"status": "stored", "memory_entries": len(avatar["memory"])}
 
 
+def save_all_memories(avatar_id: str, admin_id: str, rows: list) -> dict:
+    """
+    Replace the avatar's memory list with rows shaped like
+    [["text", True], ["text2", False]]
+    """
+    if not avatar_id or not admin_id:
+        raise ValueError("avatar_id and admin_id required")
+    avatar = load_avatar(avatar_id)
+    if admin_id != avatar.get("admin_id"):
+        raise ValueError("invalid admin_id")
+
+    sanitized: list[dict] = []
+    rows = rows or []
+    for row in rows:
+        if not row:
+            continue
+        text = (row[0] if isinstance(row, (list, tuple)) else "").strip()
+        if not text:
+            continue
+        private = bool(row[1]) if isinstance(row, (list, tuple)) and len(row) > 1 else False
+        sanitized.append({"entry": text, "private": private})
+
+    avatar["memory"] = sanitized
+    save_avatar(avatar)
+    return {"status": "saved", "memory_entries": len(sanitized)}
+
+
 def get_avatar_context(payload: Dict[str, Any]) -> Dict[str, Any]:
     payload = payload or {}
     avatar_id = payload.get("avatar_id")
@@ -241,6 +269,20 @@ def ensure_public_avatar(avatar_id: str) -> dict:
     return avatar
 
 
+def ensure_avatar_by_admin(admin_id: str) -> dict:
+    if not admin_id:
+        raise ValueError("admin_id required")
+    for path in STORE.glob("*/avatar.json"):
+        try:
+            avatar = load_avatar(path.parent.name)
+            if avatar.get("admin_id") == admin_id:
+                avatar.pop("generated_images", None)
+                return avatar
+        except Exception:
+            continue
+    raise ValueError("avatar not found for admin_id")
+
+
 def delete_generated_images(payload: Dict[str, Any]) -> Dict[str, Any]:
     payload = payload or {}
     avatar_id = payload.get("avatar_id")

persona_engine.py

@@ -1,5 +1,6 @@
 import json
 import os
+import re
 from pathlib import Path
 
 import httpx
@@ -122,6 +123,17 @@ def _call_ollama(system: str, prompt: str) -> str | None:
         return None
 
 
+def _call_backend(system: str, prompt: str) -> str | None:
+    _log_backend()
+    if BACKEND == "openai":
+        return _call_openai(system, prompt) or _call_hf(system, prompt)
+    if BACKEND == "hf":
+        return _call_hf(system, prompt)
+    if BACKEND == "ollama":
+        return _call_ollama(system, prompt)
+    return None
+
+
 def reply_as_persona(avatar: dict, message: str, history=None) -> str:
     persona = avatar.get("persona", "avatar")
     description = avatar.get("description", "")
@@ -166,14 +178,55 @@ def reply_as_persona(avatar: dict, message: str, history=None) -> str:
         ]
         if s
     ).strip()
-    _log_backend()
-    llm_reply = None
-    if BACKEND == "openai":
-        llm_reply = _call_openai(system, message) or _call_hf(system, message)
-    elif BACKEND == "hf":
-        llm_reply = _call_hf(system, message)
-    elif BACKEND == "ollama":
-        llm_reply = _call_ollama(system, message)
+    llm_reply = _call_backend(system, message)
     if llm_reply:
         return llm_reply
     return f"{persona} (described as {description or 'mysterious'}) replies to '{message}'."
+
+
+def extract_memories_from_text(text: str, max_items: int = 100) -> list[str]:
+    text = (text or "").strip()
+    if not text:
+        return []
+
+    system = (
+        "You turn raw text into concise first-person memory statements. "
+        "Respond with a JSON array of strings. Each string should be a standalone memory that could be added "
+        "to a personal knowledge base. Keep entries short (max 200 characters)."
+    )
+    prompt = (
+        f"Input text:\n{text}\n\n"
+        f"Extract at most {max_items} distinct memories. If none are found, return an empty JSON array."
+    )
+
+    response = _call_backend(system, prompt)
+    entries: list[str] = []
+    if response:
+        try:
+            parsed = json.loads(response)
+            if isinstance(parsed, str):
+                parsed = json.loads(parsed)
+            if isinstance(parsed, list):
+                entries = [str(item).strip() for item in parsed if str(item).strip()]
+        except json.JSONDecodeError:
+            pass
+        if not entries:
+            candidates = [line.strip("-• \t") for line in response.splitlines()]
+            entries = [c for c in candidates if len(c) > 3]
+
+    if not entries:
+        rough = [
+            seg.strip()
+            for seg in re.split(r"[\n\r]+|(?<=[.!?])\s+", text)
+            if seg.strip()
+        ]
+        entries = rough[:max_items]
+
+    # Deduplicate while preserving order
+    seen = set()
+    unique: list[str] = []
+    for entry in entries:
+        if entry not in seen:
+            seen.add(entry)
+            unique.append(entry)
+    return unique[:max_items]

ui_chat.py

@@ -0,0 +1,383 @@
+import html
+import gradio as gr
+
+from logic import (
+    send_message_public,
+    maybe_generate_image,
+    initial_greeting,
+    DEFAULT_AVATAR_ID,
+)
+
+# -------------------------------------------------------------
+# CSS + JS (modern UI, responsive, smooth scroll)
+# -------------------------------------------------------------
+UI_STYLE = """
+<style>
+:root {
+    --user-bg: #e8f1ff;
+    --user-border: #8cb4ff;
+
+    --avatar-bg: #dfffe0;
+    --avatar-border: #8cd190;
+
+    --panel-border: #d4d4d4;
+    --panel-radius: 16px;
+}
+
+/* Chat panel container */
+#chat-panel {
+    width: 100%;
+}
+
+/* Scrollable chat area */
+.chat-scroll {
+    max-height: 800px;
+    min-height: 340px;
+    overflow-y: auto;
+    padding: 20px;
+    background: white;
+    border: 3px solid var(--panel-border);
+    border-radius: var(--panel-radius);
+    display: flex;
+    flex-direction: column;
+    gap: 16px;
+    scroll-behavior: smooth;
+}
+
+.chat-empty {
+    text-align: center;
+    color: #6b7280;
+    font-style: italic;
+}
+
+/* Chat row alignment */
+.chat-row {
+    display: flex;
+    width: 100%;
+}
+
+.message-row.user {
+    justify-content: flex-end;
+}
+.message-row.avatar {
+    justify-content: flex-start;
+}
+
+/* Chat bubble */
+.chat-bubble {
+    width: 75%;
+    padding: 12px 14px;
+    border-radius: 14px;
+    border: 2px solid transparent;
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    box-shadow: 0 2px 6px rgba(0,0,0,0.05);
+}
+
+.chat-bubble.user {
+    background: var(--user-bg);
+    border-color: var(--user-border);
+    margin-left: auto;
+}
+.chat-bubble.avatar {
+    background: var(--avatar-bg);
+    border-color: var(--avatar-border);
+    margin-right: auto;
+}
+
+/* Inline images */
+.chat-bubble img {
+    width: 70%;
+    border-radius: 12px;
+    border: 1px solid #d0d7e2;
+}
+
+.chat-text {
+    font-size: 1rem;
+    font-weight: 600;
+}
+
+/* Mobile layout */
+@media (max-width: 768px) {
+    .chat-bubble {
+        width: 100%;
+    }
+    .chat-bubble img {
+        width: 100%;
+    }
+}
+
+/* Keep chat readable while backend events run */
+.gradio-container .block.loading,
+.gradio-container .block.pending,
+.gradio-container .loading,
+.gradio-container .pending {
+    filter: none !important;
+    opacity: 1 !important;
+}
+.gradio-container .block.loading *,
+.gradio-container .block.pending *,
+.gradio-container .loading *,
+.gradio-container .pending * {
+    filter: none !important;
+    opacity: 1 !important;
+}
+.gradio-container .block.loading::after,
+.gradio-container .block.loading::before,
+.gradio-container .block.pending::after,
+.gradio-container .block.pending::before,
+.gradio-container .loading::after,
+.gradio-container .loading::before,
+.gradio-container .pending::after,
+.gradio-container .pending::before {
+    display: none !important;
+}
+</style>
+"""
+
+SCROLL_JS_BODY = """
+const app = document.querySelector("gradio-app");
+const root = app && app.shadowRoot ? app.shadowRoot : document;
+const host = root.querySelector("#chat-panel");
+if (!host) {
+    console.warn("[scroll-js] host not found");
+} else {
+    const panel = host.querySelector(".chat-scroll") || host.querySelector(".svelte-1n1h5do") || host;
+    if (!panel) {
+        console.warn("[scroll-js] scrollable panel not found");
+    } else {
+        const run = () => {
+            panel.scrollTop = panel.scrollHeight;
+        };
+        run();
+        setTimeout(run, 32);
+        setTimeout(run, 160);
+        panel.querySelectorAll("img").forEach((img) => {
+            if (img.dataset.scrollWatcher === "1") return;
+            img.dataset.scrollWatcher = "1";
+            const fire = () => {
+                panel.scrollTop = panel.scrollHeight;
+            };
+            if (img.complete) {
+                setTimeout(fire, 32);
+            } else {
+                img.addEventListener("load", fire, { once: true });
+                img.addEventListener("error", fire, { once: true });
+            }
+        });
+        if (!panel.dataset.observeScroll) {
+            panel.dataset.observeScroll = "1";
+            const observer = new MutationObserver(() => {
+                panel.scrollTop = panel.scrollHeight;
+            });
+            observer.observe(panel, { childList: true, subtree: true });
+        }
+    }
+}
+"""
+
+SCROLL_SNIPPET = f"<script>(function(){{{SCROLL_JS_BODY}}})()</script>"
+SCROLL_BUTTON_JS = f"() => {{{SCROLL_JS_BODY}}}"
+
+
+def render_chat(history):
+    rows = ["<div class='chat-scroll'>"]
+
+    if not history:
+        rows.append("<div class='chat-empty'>Start the conversation...</div>")
+    else:
+        for entry in history:
+            speaker = entry.get("speaker", "avatar")
+            text = entry.get("text", "") or ""
+            safe_text = html.escape(text) if isinstance(text, str) else str(text)
+
+            row_class = "chat-row message-row user" if speaker == "user" else "chat-row message-row avatar"
+            bubble_class = "chat-bubble user" if speaker == "user" else "chat-bubble avatar"
+
+            html_block = [f"<div class='{row_class}'>"]
+            html_block.append(f"<div class='{bubble_class}'>")
+
+            img = entry.get("image_data")
+            if img and speaker != "user":
+                html_block.append(f"<img src='{img}' />")
+
+            html_block.append(f"<div class='chat-text'>{safe_text}</div>")
+
+            if img and speaker == "user":
+                html_block.append(f"<img src='{img}' />")
+
+            html_block.append("</div></div>")
+            rows.append("".join(html_block))
+
+    rows.append("</div>")
+    rows.append(SCROLL_SNIPPET)
+    return "\n".join(rows)
+
+
+def build_chat_tab(blocks: gr.Blocks):
+    with gr.Tab("Chat"):
+        avatar_id_input = gr.Textbox(
+            label="Avatar ID",
+            value=DEFAULT_AVATAR_ID,
+            interactive=True,
+            scale=2
+        )
+
+        chat_display = gr.HTML(render_chat([]), elem_id="chat-panel", sanitize_html=False)
+        msg_input = gr.Textbox(label="Message", placeholder="Say something...")
+        state = gr.State([])
+        pending_message = gr.State("")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                send_btn = gr.Button("Send", variant="primary")
+                tool_status = gr.Markdown("Tool used: n/a")
+            generate_toggle = gr.Checkbox(label="Generate Images", value=True)
+            clear_btn = gr.Button("Clear")
+
+        def stash_message(msg):
+            return msg, ""
+
+        def mark_processing():
+            return gr.update(value="Generating...", interactive=False)
+
+        def mark_ready():
+            return gr.update(value="Send", interactive=True)
+
+        def on_send(aid, msg, history, gen_flag):
+            history, tool = send_message_public(aid, msg, history, gen_flag)
+            return render_chat(history), "", history, f"Tool used: {tool}", gen_flag
+
+        def on_image_gen(aid, history, gen_flag):
+            history = maybe_generate_image(aid, history, gen_flag)
+            return render_chat(history), history, gen_flag
+
+        def mark_image_processing(gen_flag):
+            if not gen_flag:
+                return gr.update()
+            return gr.update(label="Generate Images (processing...)", interactive=False)
+
+        def mark_image_ready(gen_flag):
+            if not gen_flag:
+                return gr.update()
+            return gr.update(label="Generate Images", interactive=True)
+
+        send_btn.click(
+            stash_message,
+            inputs=[msg_input],
+            outputs=[pending_message, msg_input],
+            queue=False
+        ).then(
+            mark_processing,
+            outputs=[send_btn],
+            show_progress="hidden"
+        ).then(
+            on_send,
+            inputs=[avatar_id_input, pending_message, state, generate_toggle],
+            outputs=[chat_display, msg_input, state, tool_status, generate_toggle],
+            show_progress="hidden"
+        ).then(
+            mark_image_processing,
+            inputs=[generate_toggle],
+            outputs=[generate_toggle],
+            show_progress="hidden"
+        ).then(
+            on_image_gen,
+            inputs=[avatar_id_input, state, generate_toggle],
+            outputs=[chat_display, state, generate_toggle],
+            show_progress="hidden"
+        ).then(
+            mark_image_ready,
+            inputs=[generate_toggle],
+            outputs=[generate_toggle],
+            show_progress="hidden"
+        ).then(
+            mark_ready,
+            outputs=[send_btn],
+            show_progress="hidden"
+        ).then(
+            None,
+            js=SCROLL_BUTTON_JS,
+            show_progress="hidden"
+        )
+
+
+        msg_input.submit(
+            stash_message,
+            inputs=[msg_input],
+            outputs=[pending_message, msg_input],
+            queue=False
+        ).then(
+            mark_processing,
+            outputs=[send_btn],
+            show_progress="hidden"
+        ).then(
+            on_send,
+            inputs=[avatar_id_input, pending_message, state, generate_toggle],
+            outputs=[chat_display, msg_input, state, tool_status, generate_toggle],
+            show_progress="hidden"
+        ).then(
+            mark_image_processing,
+            inputs=[generate_toggle],
+            outputs=[generate_toggle],
+            show_progress="hidden"
+        ).then(
+            on_image_gen,
+            inputs=[avatar_id_input, state, generate_toggle],
+            outputs=[chat_display, state, generate_toggle],
+            show_progress="hidden"
+        ).then(
+            mark_image_ready,
+            inputs=[generate_toggle],
+            outputs=[generate_toggle],
+            show_progress="hidden"
+        ).then(
+            mark_ready,
+            outputs=[send_btn],
+            show_progress="hidden"
+        ).then(
+            None,
+            js=SCROLL_BUTTON_JS,
+            show_progress="hidden"
+        )
+
+        clear_btn.click(
+            lambda: (render_chat([]), "", [], "Tool used: n/a", True),
+            outputs=[chat_display, msg_input, state, tool_status, generate_toggle],
+            show_progress="hidden"
+        ).then(
+            None,
+            js=SCROLL_BUTTON_JS,
+            show_progress="hidden"
+        )
+
+        def load_greeting(aid):
+            hist = initial_greeting(aid)
+            return render_chat(hist), "", hist, "Tool used: greet", True
+
+        blocks.load(
+            load_greeting,
+            inputs=[avatar_id_input],
+            outputs=[chat_display, msg_input, state, tool_status, generate_toggle],
+            show_progress="hidden"
+        ).then(
+            mark_image_processing,
+            inputs=[generate_toggle],
+            outputs=[generate_toggle],
+            show_progress="hidden"
+        ).then(
+            on_image_gen,
+            inputs=[avatar_id_input, state, generate_toggle],
+            outputs=[chat_display, state, generate_toggle],
+            show_progress="hidden"
+        ).then(
+            mark_image_ready,
+            inputs=[generate_toggle],
+            outputs=[generate_toggle],
+            show_progress="hidden"
+        ).then(
+            None,
+            js=SCROLL_BUTTON_JS,
+            show_progress="hidden"
+        )

ui_creator.py

@@ -0,0 +1,140 @@
+import gradio as gr
+
+from logic import (
+    ui_upload_portrait,
+    ui_remove_portrait,
+    ui_add_context_text,
+    ui_add_context_file,
+    ui_clear_generated,
+    ui_load_avatar,
+    ui_create_avatar,
+    ui_update_memory,
+)
+
+DEMO_ADMIN_ID = "01043e7a9c7141f892d0b08e6c325f18"
+
+def build_creator_tab():
+    with gr.Tab("Creator"):
+        card_style = (
+            "border:1px solid #e0e0e0; border-radius:6px; padding:12px; background:white;"
+        )
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.HTML(
+                    f"<div style='{card_style}'>"
+                    "<div style=\"font-weight:600; font-size: 0.9rem; margin-bottom:6px\">Load Existing Avatar</div>"
+                )
+                creator_avatar_id = gr.Textbox(label="Avatar ID", value="", visible=False)
+                creator_admin_id = gr.Textbox(
+                    label="Admin ID", type="password", value=DEMO_ADMIN_ID
+                )
+                load_btn = gr.Button("Load Avatar", variant="primary", scale=1)
+                load_status = gr.Textbox(
+                    label="Load Status", value="", interactive=False, lines=1
+                )
+                gr.HTML("</div>")
+            with gr.Column(scale=1):
+                gr.HTML(
+                    f"<div style='{card_style}'>"
+                    "<div style=\"font-weight:600; font-size: 0.9rem; margin-bottom:6px\">Create New Avatar</div>"
+                )
+                new_desc = gr.Textbox(label="Name")
+                create_btn = gr.Button("Create Avatar", variant="primary", scale=1)
+                create_status = gr.Textbox(
+                    label="Create Status", value="", interactive=False, lines=1
+                )
+                gr.HTML("</div>")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                avatar_data = gr.Textbox(label="Avatar JSON", lines=8)
+                portrait_view = gr.Image(label="Portrait", type="filepath")
+
+                portrait_upload = gr.Image(label="Upload Portrait", type="filepath")
+                portrait_status = gr.Textbox(label="Portrait Status")
+
+                upload_portrait_btn = gr.Button("Save Portrait")
+                remove_portrait_btn = gr.Button("Remove Portrait")
+
+                upload_portrait_btn.click(
+                    ui_upload_portrait,
+                    inputs=[creator_avatar_id, creator_admin_id, portrait_upload],
+                    outputs=[portrait_status, portrait_view],
+                )
+
+                remove_portrait_btn.click(
+                    ui_remove_portrait,
+                    inputs=[creator_avatar_id, creator_admin_id],
+                    outputs=[portrait_status, portrait_view],
+                )
+
+            with gr.Column(scale=2):
+                gr.Markdown("### Memories")
+
+                memory_table = gr.Dataframe(
+                    headers=["memory", "private"],
+                    wrap=True,
+                    interactive=True,
+                    show_row_numbers=True,
+                )
+
+                save_edits_btn = gr.Button("Save Edited Memories")
+                save_edits_status = gr.Textbox(label="Edit Status")
+
+                save_edits_btn.click(
+                    ui_update_memory,
+                    inputs=[creator_avatar_id, creator_admin_id, memory_table],
+                    outputs=[save_edits_status],
+                )
+
+                gr.Markdown("### Add New Memory")
+
+                context_text = gr.Textbox(label="Text / URL", lines=4)
+                private_toggle = gr.Checkbox(label="Private?")
+                text_status = gr.Textbox(label="Text Status")
+
+                add_text_btn = gr.Button("Add Text Memory")
+                add_text_btn.click(
+                    ui_add_context_text,
+                    inputs=[creator_avatar_id, creator_admin_id, context_text, private_toggle],
+                    outputs=[text_status, memory_table],
+                )
+
+                context_file = gr.File(label="Upload File")
+                file_status = gr.Textbox(label="File Status")
+
+                add_file_btn = gr.Button("Add File Memory")
+                add_file_btn.click(
+                    ui_add_context_file,
+                    inputs=[creator_avatar_id, creator_admin_id, context_file, private_toggle],
+                    outputs=[file_status, memory_table],
+                )
+
+                clear_gen_btn = gr.Button("Clear Generated Images")
+                clear_gen_status = gr.Textbox(label="Generated Images Status")
+
+                clear_gen_btn.click(
+                    ui_clear_generated,
+                    inputs=[creator_avatar_id, creator_admin_id],
+                    outputs=[clear_gen_status],
+                )
+
+        load_btn.click(
+            ui_load_avatar,
+            inputs=[creator_avatar_id, creator_admin_id],
+            outputs=[avatar_data, memory_table, portrait_view, load_status, creator_avatar_id, creator_admin_id],
+        )
+
+        create_btn.click(
+            lambda: ("", [], None, "Creating new avatar...", "", DEMO_ADMIN_ID),
+            outputs=[avatar_data, memory_table, portrait_view, load_status, creator_avatar_id, creator_admin_id],
+            queue=False,
+        ).then(
+            ui_create_avatar,
+            inputs=[new_desc],
+            outputs=[create_status, avatar_data, memory_table, portrait_view, creator_avatar_id, creator_admin_id],
+        ).then(
+            lambda: "New avatar ready. Use the admin ID shown in the creator panel.",
+            outputs=[load_status],
+            queue=False,
+        )

ui_info.py

@@ -0,0 +1,9 @@
+import gradio as gr
+
+from logic import resolve_path
+
+
+def build_info_tab():
+    with gr.Tab("Info"):
+        gr.Markdown("### Avatar MCP Workflow")
+        gr.Image(label="Infographic", value=resolve_path("avatar_infographic.png"), type="filepath")