Files
mcp-home/notes/server.py
T

568 lines
25 KiB
Python

"""MCP Notes Server — reads/writes Joplin notes via Joplin CLI Data API."""
import os, sys, contextlib, base64, json, mimetypes
from typing import Annotated
import httpx
from pydantic import Field
from mcp.server.fastmcp import FastMCP
from mcp.types import TextContent, ImageContent, EmbeddedResource, BlobResourceContents
from starlette.applications import Starlette
from starlette.routing import Mount, Route
from starlette.responses import Response
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
from common import get_current_user, OAUTH_ROUTES, BearerAuthMiddleware, load_config
from pdfutil import pdf_to_content
from officeutil import office_to_content, is_office
_cfg = load_config()
DATA_API = _cfg["joplin_data_api"] # {user: {url, token}}
mcp = FastMCP("Notes", stateless_http=True,
transport_security={"enable_dns_rebinding_protection": False})
IMAGE_TYPES = {"image/jpeg", "image/png", "image/gif", "image/webp"}
def _api(user):
return DATA_API.get(user)
def _get(user, path, params=None):
api = _api(user)
if not api:
return None, "Kein Joplin-Zugang fuer diesen User"
p = dict(params or {})
p["token"] = api["token"]
try:
r = httpx.get(f"{api['url']}{path}", params=p, timeout=30)
if r.status_code >= 400:
return None, f"Joplin HTTP {r.status_code}"
return r, None
except Exception as e:
return None, str(e)
def _post(user, path, json_data):
api = _api(user)
if not api:
return None, "Kein Joplin-Zugang"
try:
r = httpx.post(f"{api['url']}{path}", params={"token": api["token"]}, json=json_data, timeout=30)
if r.status_code >= 400:
return None, f"Joplin HTTP {r.status_code}"
return r.json(), None
except Exception as e:
return None, str(e)
import re
_JOPLIN_ID = re.compile(r"^[0-9a-f]{32}$")
def _valid_id(x):
"""Joplin item-IDs sind 32 Hex-Zeichen. Verhindert URL/Query-Injection ueber note_id."""
return isinstance(x, str) and bool(_JOPLIN_ID.match(x))
def _put(user, path, json_data):
api = _api(user)
if not api:
return None, "Kein Joplin-Zugang"
try:
r = httpx.put(f"{api['url']}{path}", params={"token": api["token"]}, json=json_data, timeout=30)
if r.status_code >= 400:
return None, f"Joplin HTTP {r.status_code}"
return r.json(), None
except Exception as e:
return None, str(e)
def _delete(user, path, params=None):
api = _api(user)
if not api:
return None, "Kein Joplin-Zugang"
p = dict(params or {})
p["token"] = api["token"]
try:
r = httpx.delete(f"{api['url']}{path}", params=p, timeout=30)
if r.status_code >= 400:
return None, f"Joplin HTTP {r.status_code}"
return r, None
except Exception as e:
return None, str(e)
def _all_items(user, path, params=None):
"""Fetch all pages from a Data API list endpoint."""
items = []
page = 1
while True:
p = dict(params or {})
p["page"] = page
r, err = _get(user, path, p)
if err:
return [], err
d = r.json()
items.extend(d.get("items", []))
if not d.get("has_more"):
break
page += 1
if page > 50:
break
return items, None
MAX_ATTACHMENT_BYTES = 2 * 1024 * 1024 * 1024
def _decode_base64(content_base64):
s = re.sub(r"\s+", "", content_base64 or "")
if s.startswith("data:") and "," in s:
s = s.split(",", 1)[1]
try:
return base64.b64decode(s, validate=True), None
except Exception as e:
return None, f"Ungueltiges Base64: {e}"
def _guess_mime(filename, mime):
if mime:
return mime
return mimetypes.guess_type(filename or "")[0] or "application/octet-stream"
def _resource_link(title, mime, resource_id):
label = (title or "Anhang").replace("[", "(").replace("]", ")")
if (mime or "").startswith("image/"):
return f"![{label}](:/{resource_id})"
return f"[{label}](:/{resource_id})"
def _strip_resource_refs(body, resource_id):
"""Remove Markdown/HTML links pointing at :/resourceId from a note body."""
rid = re.escape(resource_id)
body = re.sub(r"!?\[[^\]]*\]\(:/" + rid + r'(?:\s+"[^"]*")?\)', "", body)
body = re.sub(r"<[^>]*:/" + rid + r"[^>]*>", "", body)
body = re.sub(r"\n{3,}", "\n\n", body).strip()
return body + ("\n" if body else "")
def _upload_resource(user, path, filename, content, mime, props, method="post"):
"""Create (POST) or replace content (PUT) of a Joplin resource via multipart/form-data.
Joplin expects the file in the 'data' field and the properties as JSON in the
'props' field (see Data API docs, POST/PUT /resources)."""
api = _api(user)
if not api:
return None, "Kein Joplin-Zugang"
files = {"data": (filename or "attachment.bin", content, mime or "application/octet-stream")}
data = {"props": json.dumps(props or {})}
try:
fn = httpx.post if method == "post" else httpx.put
r = fn(f"{api['url']}{path}", params={"token": api["token"]},
files=files, data=data, timeout=120)
if r.status_code >= 400:
return None, f"Joplin HTTP {r.status_code}: {r.text[:200]}"
return r.json(), None
except Exception as e:
return None, str(e)
@mcp.tool()
def list_notebooks() -> str:
"""List all Joplin notebooks (folders). Call this first to see notebook names and IDs."""
user = get_current_user()
if not user: return "Error: not authenticated"
items, err = _all_items(user, "/folders")
if err: return f"Fehler: {err}"
return "\n".join(f"{i['title']} (id: {i['id']})" for i in items) if items else "Keine Notizbuecher"
@mcp.tool()
def list_notes(
notebook: Annotated[str, Field(description="Notebook name or ID from list_notebooks. Leave empty for all notes.")] = "",
limit: Annotated[int, Field(description="Maximum number of notes")] = 50,
) -> str:
"""List notes, optionally filtered by notebook. Shows title and ID."""
user = get_current_user()
if not user: return "Error: not authenticated"
nb_id = ""
if notebook:
folders, err = _all_items(user, "/folders")
if err: return f"Fehler: {err}"
for f in folders:
if notebook.lower() in f["title"].lower() or notebook == f["id"]:
nb_id = f["id"]
break
if not nb_id:
return f"Notizbuch nicht gefunden: {notebook}"
path = f"/folders/{nb_id}/notes"
else:
path = "/notes"
items, err = _all_items(user, path, {"fields": "id,title", "order_by": "updated_time", "order_dir": "DESC"})
if err: return f"Fehler: {err}"
return "\n".join(f"{i['title']} (id: {i['id']})" for i in items[:limit]) if items else "Keine Notizen"
@mcp.tool()
def search_notes(
query: Annotated[str, Field(description="Search term — matches note titles and content. Example: 'Einkaufsliste', 'Rezept', 'Passwort'")],
) -> str:
"""Search notes by keyword (full text). Returns matching note titles and IDs."""
user = get_current_user()
if not user: return "Error: not authenticated"
items, err = _all_items(user, "/search", {"query": query, "type": "note", "fields": "id,title"})
if err: return f"Fehler: {err}"
return "\n".join(f"{i['title']} (id: {i['id']})" for i in items[:30]) if items else "Keine Treffer"
@mcp.tool()
def read_note(
note_id: Annotated[str, Field(description="Note ID from list_notes or search_notes")],
) -> str:
"""Read a note's full content (Markdown). Resource links appear as :/resourceId — use list_note_resources + read_resource for attachments."""
user = get_current_user()
if not user: return "Error: not authenticated"
if not _valid_id(note_id): return "Fehler: ungueltige note_id (erwartet 32 Hex-Zeichen)"
r, err = _get(user, f"/notes/{note_id}", {"fields": "id,title,body"})
if err: return f"Fehler: {err}"
d = r.json()
return f"# {d.get('title','?')}\n\n{d.get('body','')}"
@mcp.tool()
def list_note_resources(
note_id: Annotated[str, Field(description="Note ID from list_notes or search_notes")],
) -> str:
"""List attachments (images, PDFs, files) embedded in a note. Use read_resource with the resource ID to fetch one."""
user = get_current_user()
if not user: return "Error: not authenticated"
if not _valid_id(note_id): return "Fehler: ungueltige note_id (erwartet 32 Hex-Zeichen)"
items, err = _all_items(user, f"/notes/{note_id}/resources", {"fields": "id,title,mime,size"})
if err: return f"Fehler: {err}"
if not items:
return "Keine Anhaenge"
lines = []
for i in items:
size = i.get("size", 0)
lines.append(f"{i.get('title','?')} ({i.get('mime','?')}, {size:,} bytes) id: {i['id']}")
return "\n".join(lines)
@mcp.tool()
def read_resource(
resource_id: Annotated[str, Field(description="Resource/attachment ID from list_note_resources")],
) -> list[TextContent | ImageContent | EmbeddedResource]:
"""Read an attachment. Images shown inline, PDFs and Office documents (docx, xlsx, pptx) as extracted text, text directly, other formats as binary."""
user = get_current_user()
if not user: return [TextContent(type="text", text="Error: not authenticated")]
if not _valid_id(resource_id): return [TextContent(type="text", text="Fehler: ungueltige resource_id (erwartet 32 Hex-Zeichen)")]
# Get metadata
rmeta, err = _get(user, f"/resources/{resource_id}", {"fields": "id,title,mime,size"})
if err: return [TextContent(type="text", text=f"Fehler: {err}")]
meta = rmeta.json()
mime = meta.get("mime", "application/octet-stream")
title = meta.get("title", "attachment")
# Get blob
rfile, err = _get(user, f"/resources/{resource_id}/file")
if err: return [TextContent(type="text", text=f"Fehler: {err}")]
content = rfile.content
if mime in IMAGE_TYPES and len(content) < 10_000_000:
return [ImageContent(type="image", data=base64.b64encode(content).decode(), mimeType=mime)]
if mime.startswith("text/"):
return [TextContent(type="text", text=content.decode("utf-8", errors="replace")[:100000])]
uri = f"joplin://resource/{resource_id}/{title}"
if mime == "application/pdf" or title.lower().endswith(".pdf"):
return pdf_to_content(content, title, mime, uri=uri)
if is_office(mime, title):
return office_to_content(content, title, mime, uri=uri)
return [EmbeddedResource(type="resource", resource=BlobResourceContents(
uri=uri, blob=base64.b64encode(content).decode(), mimeType=mime))]
@mcp.tool()
def add_attachment(
note_id: Annotated[str, Field(description="Note ID from list_notes or search_notes")],
filename: Annotated[str, Field(description="File name incl. extension, e.g. 'angebot.pdf' or 'foto.jpg'. Used as resource title and to guess the MIME type.")],
content_base64: Annotated[str, Field(description="File content as a Base64 string (raw bytes). A 'data:...;base64,' prefix and line breaks are accepted.")],
mime: Annotated[str, Field(description="MIME type, e.g. 'application/pdf'. Leave empty to guess it from the filename.")] = "",
title: Annotated[str, Field(description="Title shown for the attachment in Joplin. Leave empty to use the filename.")] = "",
) -> str:
"""Add an attachment (image, PDF, any file) to a note. Uploads the file as a Joplin resource and appends a Markdown link at the end of the note body. Max 25 MB."""
user = get_current_user()
if not user: return "Error: not authenticated"
if not _valid_id(note_id): return "Fehler: ungueltige note_id (erwartet 32 Hex-Zeichen)"
if not filename: return "Fehler: filename erforderlich"
content, err = _decode_base64(content_base64)
if err: return f"Fehler: {err}"
if not content: return "Fehler: content_base64 ist leer"
if len(content) > MAX_ATTACHMENT_BYTES:
return f"Fehler: Anhang zu gross ({len(content):,} bytes, max {MAX_ATTACHMENT_BYTES:,})"
mime = _guess_mime(filename, mime)
props = {"title": title or filename, "mime": mime}
res, err = _upload_resource(user, "/resources", filename, content, mime, props, method="post")
if err: return f"Fehler: {err}"
rid = res.get("id", "")
r, err = _get(user, f"/notes/{note_id}", {"fields": "id,title,body"})
if err: return f"Anhang hochgeladen (resource id: {rid}), aber Notiz-Lesen fehlgeschlagen: {err}"
note = r.json()
new_body = (note.get("body", "") or "").rstrip() + "\n\n" + _resource_link(props["title"], mime, rid) + "\n"
_, err = _put(user, f"/notes/{note_id}", {"body": new_body})
if err: return f"Anhang hochgeladen (resource id: {rid}), aber Verlinkung fehlgeschlagen: {err}"
return f"Anhang hinzugefuegt: {props['title']} ({mime}, {len(content):,} bytes), resource id: {rid}, verlinkt in Notiz: {note.get('title','?')}"
@mcp.tool()
def update_attachment(
resource_id: Annotated[str, Field(description="Attachment/resource ID from list_note_resources")],
content_base64: Annotated[str, Field(description="New file content as a Base64 string. Leave empty to keep the current content (then only title/mime change).")] = "",
filename: Annotated[str, Field(description="New file name, only used together with content_base64.")] = "",
mime: Annotated[str, Field(description="New MIME type. Leave empty to keep the current one.")] = "",
title: Annotated[str, Field(description="New title shown in Joplin. Leave empty to keep the current one.")] = "",
) -> str:
"""Edit an attachment: replace its file content and/or change its title and MIME type. Only the given fields are changed. Get resource_id from list_note_resources."""
user = get_current_user()
if not user: return "Error: not authenticated"
if not _valid_id(resource_id): return "Fehler: ungueltige resource_id (erwartet 32 Hex-Zeichen)"
if not content_base64 and not title and not mime:
return "Nichts zu aendern: content_base64, title oder mime angeben"
rmeta, err = _get(user, f"/resources/{resource_id}", {"fields": "id,title,mime,filename"})
if err: return f"Fehler: {err}"
meta = rmeta.json()
new_title = title or meta.get("title", "") or "attachment"
new_mime = mime or meta.get("mime", "")
if content_base64:
content, err = _decode_base64(content_base64)
if err: return f"Fehler: {err}"
if not content: return "Fehler: content_base64 ist leer"
if len(content) > MAX_ATTACHMENT_BYTES:
return f"Fehler: Anhang zu gross ({len(content):,} bytes, max {MAX_ATTACHMENT_BYTES:,})"
fn = filename or meta.get("filename") or new_title
new_mime = _guess_mime(fn, new_mime)
props = {"title": new_title, "mime": new_mime}
res, err = _upload_resource(user, f"/resources/{resource_id}", fn, content, new_mime, props, method="put")
if err: return f"Fehler: {err}"
return f"Anhang-Inhalt ersetzt: {new_title} ({new_mime}, {len(content):,} bytes), resource id: {resource_id}"
payload = {}
if title: payload["title"] = title
if mime: payload["mime"] = mime
d, err = _put(user, f"/resources/{resource_id}", payload)
if err: return f"Fehler: {err}"
return f"Anhang aktualisiert ({', '.join(sorted(payload))}): {d.get('title', new_title)} (resource id: {resource_id})"
@mcp.tool()
def delete_attachment(
resource_id: Annotated[str, Field(description="Attachment/resource ID from list_note_resources")],
note_id: Annotated[str, Field(description="Note ID whose body also references the attachment. Recommended: only then is the Markdown link reliably removed. Leave empty to try all notes that Joplin reports for the resource.")] = "",
remove_links: Annotated[bool, Field(description="True (default): also remove the Markdown links to the attachment from the note body. False: keep the (then broken) links.")] = True,
) -> str:
"""Delete an attachment permanently (Joplin has no trash for resources) and remove its links from the note body. Get resource_id from list_note_resources."""
user = get_current_user()
if not user: return "Error: not authenticated"
if not _valid_id(resource_id): return "Fehler: ungueltige resource_id (erwartet 32 Hex-Zeichen)"
if note_id and not _valid_id(note_id): return "Fehler: ungueltige note_id (erwartet 32 Hex-Zeichen)"
rmeta, err = _get(user, f"/resources/{resource_id}", {"fields": "id,title"})
if err: return f"Fehler: {err}"
rtitle = rmeta.json().get("title", resource_id)
cleaned = []
if remove_links:
notes, err = _all_items(user, f"/resources/{resource_id}/notes", {"fields": "id,title"})
if err: return f"Fehler: {err}"
if note_id:
notes = [n for n in notes if n["id"] == note_id] or [{"id": note_id}]
for n in notes:
r, err = _get(user, f"/notes/{n['id']}", {"fields": "id,title,body"})
if err: continue
d = r.json()
body = d.get("body", "") or ""
if f":/{resource_id}" in body:
_, err = _put(user, f"/notes/{n['id']}", {"body": _strip_resource_refs(body, resource_id)})
if not err:
cleaned.append(d.get("title", n["id"]))
_, err = _delete(user, f"/resources/{resource_id}")
if err: return f"Fehler beim Loeschen: {err}"
msg = f"Anhang geloescht (nicht wiederherstellbar): {rtitle} (resource id: {resource_id})"
if cleaned:
msg += f", Referenz entfernt aus: {', '.join(cleaned)}"
elif not note_id:
msg += ". Hinweis: keine verlinkte Notiz gefunden (Joplins Link-Tabelle kann leer sein) — note_id angeben, um den Link sicher zu entfernen"
return msg
@mcp.tool()
def create_note(
notebook: Annotated[str, Field(description="Notebook name or ID where the note is created")],
title: Annotated[str, Field(description="Note title")],
body: Annotated[str, Field(description="Note content in Markdown")],
) -> str:
"""Create a new note in the specified notebook."""
user = get_current_user()
if not user: return "Error: not authenticated"
folders, err = _all_items(user, "/folders")
if err: return f"Fehler: {err}"
nb_id = None
for f in folders:
if notebook.lower() in f["title"].lower() or notebook == f["id"]:
nb_id = f["id"]
break
if not nb_id: return f"Notizbuch nicht gefunden: {notebook}"
d, err = _post(user, "/notes", {"title": title, "body": body, "parent_id": nb_id})
if err: return f"Fehler: {err}"
return f"Notiz erstellt: {title} (id: {d.get('id','?')})"
@mcp.tool()
def update_note(
note_id: Annotated[str, Field(description="Note ID from list_notes or search_notes")],
title: Annotated[str, Field(description="New title. Leave empty to keep the current title.")] = "",
body: Annotated[str, Field(description="New content in Markdown, replaces the whole body. Leave empty to keep the current body. Tip: read_note first, modify, then pass the full new text.")] = "",
notebook: Annotated[str, Field(description="Notebook name or ID to move the note to. Leave empty to keep it where it is.")] = "",
) -> str:
"""Update an existing note: change title and/or body, or move it to another notebook. Only the given fields are changed."""
user = get_current_user()
if not user: return "Error: not authenticated"
if not _valid_id(note_id): return "Fehler: ungueltige note_id (erwartet 32 Hex-Zeichen)"
payload = {}
if title: payload["title"] = title
if body: payload["body"] = body
if notebook:
folders, err = _all_items(user, "/folders")
if err: return f"Fehler: {err}"
nb_id = None
for f in folders:
if notebook.lower() in f["title"].lower() or notebook == f["id"]:
nb_id = f["id"]
break
if not nb_id: return f"Notizbuch nicht gefunden: {notebook}"
payload["parent_id"] = nb_id
if not payload:
return "Nichts zu aendern: title, body oder notebook angeben"
d, err = _put(user, f"/notes/{note_id}", payload)
if err: return f"Fehler: {err}"
changed = ", ".join(sorted(payload))
return f"Notiz aktualisiert ({changed}): {d.get('title','?')} (id: {d.get('id', note_id)})"
@mcp.tool()
def delete_note(
note_id: Annotated[str, Field(description="Note ID from list_notes or search_notes")],
permanent: Annotated[bool, Field(description="False (default): move to trash, recoverable in Joplin. True: delete permanently, NOT recoverable.")] = False,
) -> str:
"""Delete a note. By default it goes to Joplin's trash; permanent=True removes it for good."""
user = get_current_user()
if not user: return "Error: not authenticated"
if not _valid_id(note_id): return "Fehler: ungueltige note_id (erwartet 32 Hex-Zeichen)"
r, err = _get(user, f"/notes/{note_id}", {"fields": "id,title"})
if err: return f"Fehler: {err}"
note_title = r.json().get("title", "?")
params = {"permanent": "1"} if permanent else None
_, err = _delete(user, f"/notes/{note_id}", params)
if err: return f"Fehler: {err}"
if permanent:
return f"Notiz ENDGUELTIG geloescht: {note_title}"
return f"Notiz in den Papierkorb verschoben: {note_title} (in Joplin wiederherstellbar)"
async def raw_resource(request):
"""Roher Resource-Transfer (beliebige Binaerdateien).
GET /raw?resource_id=<id> -> Resource als Rohbytes
PUT /raw?resource_id=<id>[&filename=&mime=&title=] -> vorhandene Resource ersetzen
PUT /raw?note_id=<id>&filename=<name>[&mime=&title=] -> neue Resource anlegen + in Notiz verlinken
Token-geschuetzt ueber BearerAuthMiddleware.
"""
user = get_current_user()
if not user:
return Response("unauthorized", status_code=401)
q = request.query_params
if request.method == "GET":
rid = q.get("resource_id", "")
if not _valid_id(rid):
return Response("invalid resource_id", status_code=400)
rmeta, err = _get(user, f"/resources/{rid}", {"fields": "id,title,mime"})
if err:
return Response(f"Fehler: {err}", status_code=404)
meta = rmeta.json()
mime = meta.get("mime", "application/octet-stream")
title = meta.get("title", "attachment")
rfile, err = _get(user, f"/resources/{rid}/file")
if err:
return Response(f"Fehler: {err}", status_code=404)
return Response(rfile.content, media_type=mime,
headers={"Content-Disposition": f'attachment; filename="{title}"'})
# PUT (Upload / Ersetzen)
content = await request.body()
if not content:
return Response("leerer Body", status_code=400)
if len(content) > MAX_ATTACHMENT_BYTES:
return Response(f"zu gross ({len(content):,} > {MAX_ATTACHMENT_BYTES:,})", status_code=413)
rid = q.get("resource_id", "")
note_id = q.get("note_id", "")
filename = q.get("filename", "")
mime = q.get("mime", "")
title = q.get("title", "")
if rid:
if not _valid_id(rid):
return Response("invalid resource_id", status_code=400)
rmeta, err = _get(user, f"/resources/{rid}", {"fields": "id,title,mime,filename"})
if err:
return Response(f"Fehler: {err}", status_code=404)
meta = rmeta.json()
fn = filename or meta.get("filename") or meta.get("title") or "attachment.bin"
new_mime = _guess_mime(fn, mime or meta.get("mime", ""))
new_title = title or meta.get("title") or fn
props = {"title": new_title, "mime": new_mime}
res, err = _upload_resource(user, f"/resources/{rid}", fn, content, new_mime, props, method="put")
if err:
return Response(f"Fehler: {err}", status_code=502)
return Response(f"ok resource {rid} ersetzt ({len(content):,} bytes)", status_code=200)
if note_id:
if not _valid_id(note_id):
return Response("invalid note_id", status_code=400)
if not filename:
return Response("filename erforderlich", status_code=400)
new_mime = _guess_mime(filename, mime)
new_title = title or filename
props = {"title": new_title, "mime": new_mime}
res, err = _upload_resource(user, "/resources", filename, content, new_mime, props, method="post")
if err:
return Response(f"Fehler: {err}", status_code=502)
new_rid = res.get("id", "")
r, err = _get(user, f"/notes/{note_id}", {"fields": "id,title,body"})
if err:
return Response(f"Anhang angelegt ({new_rid}), Notiz-Lesen fehlgeschlagen: {err}", status_code=200)
note = r.json()
new_body = (note.get("body", "") or "").rstrip() + "\n\n" + _resource_link(new_title, new_mime, new_rid) + "\n"
_, err = _put(user, f"/notes/{note_id}", {"body": new_body})
if err:
return Response(f"Anhang angelegt ({new_rid}), Verlinkung fehlgeschlagen: {err}", status_code=200)
return Response(f"ok resource {new_rid} angelegt + verlinkt", status_code=200)
return Response("resource_id oder note_id erforderlich", status_code=400)
def create_app():
from contextlib import asynccontextmanager
mcp_app = mcp.streamable_http_app()
@asynccontextmanager
async def lifespan(app):
async with contextlib.AsyncExitStack() as stack:
await stack.enter_async_context(mcp_app.router.lifespan_context(mcp_app))
yield
routes = list(OAUTH_ROUTES) + [
Route("/raw", raw_resource, methods=["GET", "PUT"]),
] + [Mount("/", app=mcp_app)]
app = Starlette(routes=routes, lifespan=lifespan)
app.add_middleware(BearerAuthMiddleware)
return app
if __name__ == "__main__":
import uvicorn
uvicorn.run(create_app(), host="0.0.0.0", port=5104)