Poe Server Bots ermöglichen es Entwicklern, externe Computerinfrastruktur, benutzerdefinierte Machine-Learning-Modelle und proprietäre Logik direkt mit Quoras Poe-Plattform über ein standardisiertes HTTP-Protokoll auf Basis von Server-Sent Events (SSE) zu verbinden. Im Gegensatz zu standardmäßigen Prompt-Bots, die auf den gehosteten kommerziellen Modellen von Poe mit benutzerdefinierten System-Prompts basieren, geben Server-Bots den Engineering-Teams die vollständige Kontrolle über Backend-Inferenz-Engines, private Gewichte, Retrieval-Augmented Generation (RAG)-Pipelines und externe API-Integrationen. Indem benutzerdefinierte Modelle in der schlanken Python-Bibliothek fastapi_poe verpackt und der Dienst auf einem öffentlich erreichbaren Endpunkt bereitgestellt wird, können Entwickler proprietäre KI-Tools sofort an die globale Benutzerbasis von Poe über Web-, iOS-, Android- und Desktop-Apps verteilen.
Architektur und das Poe Server Bot Protokoll
Die Kommunikation zwischen Poe und Ihrem benutzerdefinierten Backend folgt einem asynchronen Client-Server-Modell über HTTPS. Wenn ein Benutzer eine Nachricht an Ihren Server-Bot auf Poe sendet, leitet die Poe-Infrastruktur den Nachrichtenkontext als HTTP-POST-Anfrage an Ihren festgelegten Server-Endpunkt weiter. Ihr Server verarbeitet die eingehende Nutzlast (Payload) und streamt die generierte Antwort mithilfe von Server-Sent Events (SSE) zurück an Poe. Diese Architektur sorgt für geringe Latenzzeiten und bietet dem Endbenutzer ein Token-Streaming in Echtzeit.
Die Protokollspezifikation standardisiert mehrere Ereignis- und Anfragetypen:
QueryRequest: Enthält den vollständigen Konversationskontext, einschließlich vergangener Nachrichten im Thread (query), die eindeutige Konversationskennung (conversation_id), die Benutzerkennung (user_id), Nachrichtenmetadaten und Client-Fähigkeiten.PartialResponse: Der atomare Streaming-Block (Chunk), der von Ihrem Server ausgegeben wird. Jede teilweise Antwort liefert dem Client inkrementellen Text, Daten-Nutzlasten oder Statusaktualisierungen.SettingsRequest/SettingsResponse: Ermöglicht Ihrem Server, Bot-Level-Konfigurationen mit Poe auszuhandeln, z. B. Einführungsbegrüßungen, Berechtigungen für Dateianhänge, vorgeschlagene Antworten und Abhängigkeitsdeklarationen für Bot-to-Bot-Abfragen.ReportFeedbackRequestundReportErrorRequest: Bieten Telemetrie- und Feedback-Rückrufe (Callbacks) von Poe an Ihren Server, wenn Benutzer Nachrichten bewerten oder clientseitige Übertragungsfehler auftreten.
Um Anfragen zu authentifizieren und Ihr Backend vor unbefugtem Datenverkehr zu schützen, stellt Poe einen Zugangsschlüssel (Access Key) aus. Ihr Server überprüft diesen Schlüssel anhand des Headers Authorization: Bearer <access_key>, der mit jeder eingehenden Anfrage gesendet wird.
| Component | Role in Server Bot Workflow | Key Configuration / Method |
|---|---|---|
fastapi_poe | Python-SDK, das das Poe-Protokoll auf Basis von FastAPI und Starlette implementiert | fp.make_app(), fp.run() |
PoeBot | Basisklasse, die Bot-Verhalten und Ereignishandler definiert | get_response(), get_settings() |
| Poe Gateway | Leitet Benutzereingaben weiter und überprüft die Reaktionsfähigkeit des Endpunkts | https://poe.com/create_bot?server=1 |
| Inference Server | Hostet Modellgewichte (z. B. vLLM, TGI, Ollama oder benutzerdefiniertes PyTorch) | Asynchroner Streaming-Generator |
| Access Key | Authentifiziert eingehende HTTP-POST-Aufrufe von Poe | Geheimer Token, der an make_app() übergeben wird |
Einrichten der Entwicklungsumgebung
Die offizielle Bibliothek fastapi_poe bietet den schnellsten Weg zur Implementierung eines kompatiblen Server-Bots. Sie abstrahiert HTTP-Parsing, Ereignis-Serialisierung und Authentifizierung in einer erweiterbaren asynchronen Schnittstelle.
Beginnen Sie mit der Installation von fastapi-poe zusammen mit einem ASGI-Server wie Uvicorn:
pip install fastapi-poe uvicorn
Ein minimaler Server-Bot leitet sich von PoeBot ab und implementiert den Generator get_response:
import fastapi_poe as fp
from typing import AsyncIterable
class EchoBot(fp.PoeBot):
async def get_response(
self, request: fp.QueryRequest
) -> AsyncIterable[fp.PartialResponse]:
last_message = request.query[-1].content
yield fp.PartialResponse(text=f"Received: {last_message}")
async def get_settings(
self, setting: fp.SettingsRequest
) -> fp.SettingsResponse:
return fp.SettingsResponse(
introduction_message="Welcome! This bot is running on a custom backend.",
allow_attachments=False
)
bot = EchoBot()
app = fp.make_app(bot, access_key="YOUR_SECRET_ACCESS_KEY")
if __name__ == "__main__":
fp.run(bot, access_key="YOUR_SECRET_ACCESS_KEY", port=8080)
Während der lokalen Prototyperstellung können Sie Ihren lokalen Port (z. B. 8080) über ein Tunneling-Tool wie ngrok oder Cloudflare Tunnels für das öffentliche Internet freigeben:
ngrok http 8080
Dadurch wird eine temporäre öffentliche HTTPS-URL (z. B. https://abcdef123.ngrok-free.app) generiert, die Sie für sofortige Tests in die Bot-Registrierungsoberfläche von Poe eingeben können.
Bereitstellen benutzerdefinierter Modelle und Inferenz-Pipelines
Das Verbinden eines Server-Bots mit einem benutzerdefinierten Modell beinhaltet die Überbrückung eingehender QueryRequest-Nachrichten zu einer Inferenz-Engine und das Streaming der generierten Token als PartialResponse-Objekte.
Integration in ein vLLM- oder Hugging Face-Inferenz-Backend
Beim Ausführen von Open-Weights-Modellen (wie Llama 3, Mistral oder Qwen) auf dedizierter GPU-Hardware liefert deren Bereitstellung über eine optimierte Engine wie vLLM oder Hugging Face Text Generation Inference (TGI) einen hohen Durchsatz und kontinuierliches Batching.
Das folgende Beispiel veranschaicht einen Poe-Server-Bot, der Anfragen an einen OpenAI-kompatiblen vLLM-Inferenzserver weiterleitet:
import os
import fastapi_poe as fp
from openai import AsyncOpenAI
from typing import AsyncIterable
# Connect to local or remote vLLM endpoint
client = AsyncOpenAI(
base_url=os.environ.get("VLLM_BASE_URL", "http://localhost:8000/v1"),
api_key=os.environ.get("VLLM_API_KEY", "EMPTY"),
)
class CustomModelBot(fp.PoeBot):
async def get_response(
self, request: fp.QueryRequest
) -> AsyncIterable[fp.PartialResponse]:
# Convert Poe conversation history to chat messages
messages = []
for message in request.query:
role = "user" if message.role == "user" else "assistant"
messages.append({"role": role, "content": message.content})
try:
stream = await client.chat.completions.create(
model="meta-llama/Meta-Llama-3-8B-Instruct",
messages=messages,
stream=True,
temperature=0.7,
max_tokens=1024,
)
async for chunk in stream:
token = chunk.choices[0].delta.content
if token:
yield fp.PartialResponse(text=token)
except Exception as e:
yield fp.ErrorResponse(
text=f"An error occurred during inference: {str(e)}",
allow_retry=True
)
async def get_settings(
self, setting: fp.SettingsRequest
) -> fp.SettingsResponse:
return fp.SettingsResponse(
introduction_message="Powered by a custom open-source model running on dedicated infrastructure.",
enable_image_comprehension=False,
allow_attachments=False
)
bot = CustomModelBot()
app = fp.make_app(bot, access_key=os.environ.get("POE_ACCESS_KEY"))
Umgang mit Multi-Turn-Kontext und Anhängen
Poe sendet den vollständigen Dialogverlauf chronologisch geordnet im Array request.query. Wenn Ihr benutzerdefiniertes Modell über ein begrenztes Kontextfenster (Context Window) verfügt, sollte die Logik Ihres Server-Bots frühere Gesprächsrunden (Turns) vor der Tokenisierung kürzen oder zusammenfassen.
Wenn Ihr Bot allow_attachments=True in get_settings aktiviert, werden Datei-Uploads (Bilder, PDFs, Textdokumente) in request.query[-1].attachments angezeigt. Jedes Anhangobjekt enthält eine Download-URL und einen MIME-Typ, sodass Ihr Backend das Asset herunterladen, OCR durchführen, Vision-Codierung ausführen oder das Dokument in einen Vektorspeicher einbetten kann, bevor eine Antwort generiert wird.
Hosting-Optionen für Server-Bots
Da Poe einen ununterbrochenen HTTPS-Endpunkt erfordert, der in der Lage ist, SSE-Antworten zu streamen, hängt die Auswahl der richtigen Hosting-Plattform von Ihrer Modellgröße, Ihren Rechenanforderungen und Ihrem Budget ab.
Serverless GPU-Bereitstellung mit Modal
Modal bietet erstklassige Unterstützung für Poe-Server-Bots, sodass Entwickler die GPU-Infrastruktur als Code definieren und nur für die tatsächliche Ausführungszeit bezahlen können. Modal skaliert Container-Instanzen automatisch von null an und stellt eine HTTPS-URL bereit.
Ein produktionsbereites Modal-Bereitstellungsskript:
import os
import modal
import fastapi_poe as fp
app = modal.App("poe-custom-model-bot")
# Define container environment with dependencies
image = (
modal.Image.debian_slim()
.pip_install("fastapi-poe", "openai")
)
@app.function(
image=image,
secrets=[modal.Secret.from_name("poe-custom-model-secrets")],
keep_warm=1, # Keeps one instance ready to prevent cold starts
)
@modal.asgi_app()
def fastapi_app():
from bot_implementation import CustomModelBot
bot = CustomModelBot()
return fp.make_app(bot, access_key=os.environ["POE_ACCESS_KEY"])
Das Bereitstellen dieses Dienstes mit modal deploy app.py gibt eine permanente URL aus wie:
https://<organization>--poe-custom-model-bot-fastapi-app.modal.run.
Containerisiertes Hosting bei Cloud-Anbietern (AWS, GCP, Render, Fly.io)
Für Teams, die proprietäre Inferenzcluster betreiben oder verwaltete Containerplattformen nutzen:
- Anwendung dockerisieren: Erstellen Sie ein leichtgewichtiges Dockerfile, das
uvicorn app:app --host 0.0.0.0 --port 8080 --workers 4ausführt. - Reverse Proxy und SSL: Stellen Sie hinter einem Ingress-Controller (z. B. AWS ALB, Cloudflare oder Nginx) bereit, der langlebige HTTP-Verbindungen und das Streamen stückweiser (chunked) Antworten unterstützt. Stellen Sie sicher, dass die Proxy-Timeouts (z. B.
proxy_read_timeout) auf mindestens 300 Sekunden konfiguriert sind, um Abbrüche mitten im Stream zu verhindern. - Umgebungsgeheimnisse: Injizieren Sie den
POE_ACCESS_KEYund die Inferenzanmeldeinformationen sicher über Container-Umgebungsvariablen.
Registrieren und Konfigurieren des Bots auf Poe
Sobald Ihr Server bereitgestellt und über öffentliches HTTPS zugänglich ist, schließen Sie die Registrierung auf der Poe-Plattform ab:
- Navigieren Sie zu poe.com/create_bot?server=1.
- Bot-Handle: Wählen Sie eine eindeutige alphanumerische Kennung (z. B.
@MyCustomModel). Dies bildet den öffentlichen Link für Ihren Bot. - Bot-Typ: Stellen Sie sicher, dass "Server bot" ausgewählt ist.
- Server-URL: Geben Sie Ihren vollständigen öffentlichen Endpunkt ein (z. B.
https://your-domain.com/oder Ihre Modal-Bereitstellungs-URL). - Zugangsschlüssel (Access Key): Fügen Sie den geheimen Token ein, der in Ihrem Serveraufruf
fp.make_app()konfiguriert wurde. Poe wird diesen Token bei jeder Testanfrage validieren. - Profildetails: Legen Sie Ihren Anzeigenamen, eine Beschreibung, einen Avatar und für Benutzer sichtbare Systemanweisungen fest.
- Sichtbarkeit: Wählen Sie aus, ob der Bot privat bleiben soll (nur für Sie oder bestimmte Teammitglieder zugänglich) oder öffentlich sein soll (durchsuchbar im Poe Explore-Verzeichnis).
Klicken Sie auf Create Bot. Poe überprüft sofort die Konnektivität, indem es eine SettingsRequest an Ihren Endpunkt sendet. Wenn der Server eine gültige Antwort zurückgibt, wird der Bot aktiviert.
Monetarisierung und Compute-Point-Wirtschaft
Poe bietet eine native Creator-Monetarisierung für Server-Bots, mit der Entwickler Einnahmen erzielen können, während Benutzer mit ihren Tools interagieren.
Preis pro Nachricht und die Bot-Monetarisierungs-API
Ersteller können in den Bot-Einstellungen feste Compute-Point-Kosten pro Nachricht festlegen oder die Bot-Monetarisierungs-API für eine dynamische, nutzungsbasierte Abrechnung nutzen:
- Abonnement-Umsatzbeteiligung: Wenn neue Benutzer nach der Interaktion mit Ihrem Bot Poe abonnieren, erhalten Sie eine Affiliate-Auszahlung.
- Verbrauch von Compute Points: Wenn bestehende Poe-Abonnenten oder kostenlose Benutzer Compute Points für Ihren Bot ausgeben, erzielen Sie Einnahmen im Verhältnis zu den verbrauchten Punkten.
- Variable Preisgestaltung: Wenn Ihr Modell Aufgaben mit unvorhersehbaren Rechenkosten ausführt (z. B. hochauflösendes Rendern von Bildern oder Analyse von Dokumenten mit langem Kontext), können Sie mithilfe der Endpunkte
authorize_costundcapture_costvariable Preise konfigurieren. Den Benutzern wird eine klarerate_cardoder eincost_labelangezeigt, bevor kostenintensive Operationen ausgeführt werden.
# Setting dynamic rate cards in SettingsResponse
async def get_settings(self, setting: fp.SettingsRequest) -> fp.SettingsResponse:
return fp.SettingsResponse(
introduction_message="Professional analysis bot with dynamic compute points.",
cost_label="50-200 pts",
rate_card="* Base Query: 50 points\n* Extended Analysis: 150-200 points"
)
Best Practices für die Produktion
Die Bereitstellung eines zuverlässigen Server-Bots erfordert die Bewältigung von Netzwerkvolatilität, Latenzbudgets und Betriebs-Telemetrie:
- Implementieren Sie sofortiges Streaming: Benutzer empfinden eine geringe Latenz, wenn das erste Token schnell erscheint. Vermeiden Sie es, gesamte Modellgenerierungen im Speicher zu puffern, bevor Sie sie ausgeben. Beginnen Sie mit der Ausgabe von Token, sobald der erste Chunk von Ihrem Inferenz-Backend eintrifft.
- Elegante Fehlerbehandlung (Graceful Recovery): Wickeln Sie Modellaufrufe in strukturierte Ausnahmehandler (Exception Handlers) ein. Wenn ein vorgelagerter (upstream) GPU-Worker fehlschlägt, geben Sie eine
fp.ErrorResponsemit einer klaren Erklärung zurück und setzen Sieallow_retry=True, damit der Benutzer die Abfrage ohne Neuladen der App erneut auslösen kann. - Vorgeschlagene Follow-ups: Verbessern Sie das Engagement, indem Sie am Ende einer Antwort vorgeschlagene Antworten über
fp.MetaResponse(suggested_replies=["Explain further", "Provide code sample"])anhängen. - Telemetrie überwachen: Implementieren Sie die
on_feedback-Methode in IhrerPoeBot-Klasse, um positive (Daumen hoch) und negative (Daumen runter) Bewertungen direkt in Ihrer Observability-Plattform (z. B. Datadog, Prometheus oder Grafana) zu protokollieren.