Comment les développeurs créent et hébergent des bots de serveur basés sur API sur Poe pour déployer des modèles personnalisés

Les Poe Server Bots permettent aux développeurs de connecter une infrastructure informatique externe, des modèles d'apprentissage automatique personnalisés et une logique propriétaire directement à la plateforme Poe de Quora en utilisant un protocole HTTP standard basé sur les Server-Sent Events (SSE). Contrairement aux robots d'invite standard qui s'appuient sur les modèles commerciaux hébergés de Poe avec des invites système personnalisées, les robots serveurs donnent aux équipes d'ingénierie un contrôle total sur les moteurs d'inférence backend, les poids privés, les pipelines de génération augmentée par la recherche (RAG) et les intégrations d'API externes. En encapsulant des modèles personnalisés dans la bibliothèque Python légère fastapi_poe et en déployant le service sur un point de terminaison publiquement accessible, les développeurs peuvent distribuer instantanément des outils d'IA propriétaires à la base d'utilisateurs mondiale de Poe sur les applications Web, iOS, Android et de bureau.

Architecture et le Protocole Poe Server Bot

La communication entre Poe et votre backend personnalisé suit un modèle client-serveur asynchrone sur HTTPS. Lorsqu'un utilisateur envoie un message à votre robot serveur sur Poe, l'infrastructure Poe transfère le contexte du message en tant que requête HTTP POST vers le point de terminaison de votre serveur désigné. Votre serveur traite la charge utile entrante et diffuse la réponse générée vers Poe à l'aide des Server-Sent Events (SSE). Cette architecture garantit une faible latence et fournit une diffusion de jetons (tokens) en temps réel à l'utilisateur final.

La spécification du protocole standardise plusieurs types d'événements et de requêtes :

• QueryRequest : Contient le contexte conversationnel complet, y compris les messages passés dans le fil (query), l'identifiant de conversation unique (conversation_id), l'identifiant utilisateur (user_id), les métadonnées du message et les capacités du client.
• PartialResponse : Le bloc de diffusion atomique émis par votre serveur. Chaque réponse partielle fournit du texte incrémentiel, des charges utiles de données ou des mises à jour d'état au client.
• SettingsRequest / SettingsResponse : Permet à votre serveur de négocier des configurations au niveau du robot avec Poe, telles que les messages d'introduction, les autorisations de pièces jointes, les suggestions de réponses et les déclarations de dépendances pour les requêtes entre robots.
• ReportFeedbackRequest et ReportErrorRequest : Fournissent des rappels (callbacks) de télémétrie et de commentaires de Poe à votre serveur lorsque les utilisateurs évaluent des messages ou lorsque des erreurs de transmission côté client se produisent.

Pour authentifier les requêtes et protéger votre backend contre le trafic non autorisé, Poe émet une clé d'accès (Access Key). Votre serveur vérifie cette clé par rapport à l'en-tête Authorization: Bearer <access_key> envoyé avec chaque requête entrante.

Configuration de l'environnement de développement

La bibliothèque officielle fastapi_poe offre la voie la plus rapide pour implémenter un robot serveur conforme. Elle abstrait l'analyse HTTP, la sérialisation des événements et l'authentification dans une interface asynchrone extensible.

Commencez par installer fastapi-poe avec un serveur ASGI tel qu'Uvicorn :

pip install fastapi-poe uvicorn

Un robot serveur minimal sous-classe PoeBot et implémente le générateur 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)

Lors du prototypage local, vous pouvez exposer votre port local (par exemple, 8080) à l'Internet public à l'aide d'un outil de tunneling comme ngrok ou Cloudflare Tunnels :

ngrok http 8080

Cela génère une URL HTTPS publique temporaire (par exemple, https://abcdef123.ngrok-free.app) que vous pouvez introduire dans l'interface d'enregistrement de robot de Poe pour des tests immédiats.

Déploiement de Modèles Personnalisés et Pipelines d'Inférence

Connecter un robot serveur à un modèle personnalisé implique de relier les messages QueryRequest entrants à un moteur d'inférence et de diffuser les jetons générés sous forme d'objets PartialResponse.

Intégration avec un backend d'inférence vLLM ou Hugging Face

Lors de l'exécution de modèles à poids ouverts (tels que Llama 3, Mistral ou Qwen) sur du matériel GPU dédié, les servir via un moteur optimisé tel que vLLM ou Hugging Face Text Generation Inference (TGI) offre un débit élevé et un traitement par lots continu.

L'exemple suivant illustre un robot serveur Poe transférant des requêtes vers un serveur d'inférence vLLM compatible OpenAI :

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"))

Gestion du Contexte Multi-Tours et des Pièces Jointes

Poe envoie l'historique complet des dialogues dans le tableau request.query, ordonné chronologiquement. Si votre modèle personnalisé a une fenêtre de contexte limitée, la logique de votre robot serveur doit élaguer ou résumer les tours précédents avant la tokenisation.

Lorsque votre robot active allow_attachments=True dans get_settings, les téléchargements de fichiers (images, PDF, documents texte) apparaissent dans request.query[-1].attachments. Chaque objet pièce jointe contient une URL de téléchargement et un type MIME, permettant à votre backend de télécharger la ressource, d'effectuer une ROC (OCR), d'exécuter un encodage de vision ou d'intégrer le document dans un magasin vectoriel avant de générer une réponse.

Options d'Hébergement pour les Robots Serveurs

Étant donné que Poe nécessite un point de terminaison HTTPS ininterrompu capable de diffuser des réponses SSE, la sélection de la bonne plateforme d'hébergement dépend de la taille de votre modèle, des exigences de calcul et du budget.

Déploiement GPU Serverless avec Modal

Modal offre un support de premier ordre pour les robots serveurs Poe, permettant aux développeurs de définir l'infrastructure GPU sous forme de code et de ne payer que pour le temps d'exécution réel. Modal met automatiquement à l'échelle les instances de conteneurs à partir de zéro et fournit une URL HTTPS.

Un script de déploiement Modal prêt pour la production :

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"])

Le déploiement de ce service avec modal deploy app.py génère une URL permanente telle que : https://<organization>--poe-custom-model-bot-fastapi-app.modal.run.

Hébergement Conteneurisé sur des Fournisseurs Cloud (AWS, GCP, Render, Fly.io)

Pour les équipes exécutant des clusters d'inférence propriétaires ou exploitant des plateformes de conteneurs gérées :

1. Dockeriser l'Application : Créez un Dockerfile léger exécutant uvicorn app:app --host 0.0.0.0 --port 8080 --workers 4.
2. Reverse Proxy et SSL : Déployez derrière un contrôleur d'entrée (tel que AWS ALB, Cloudflare, ou Nginx) qui prend en charge les connexions HTTP de longue durée et les réponses fragmentées (chunked) en continu. Assurez-vous que les délais d'attente du proxy (par exemple, proxy_read_timeout) sont configurés pour au moins 300 secondes afin d'éviter les déconnexions en cours de diffusion.
3. Secrets d'Environnement : Injectez POE_ACCESS_KEY et les informations d'identification d'inférence en toute sécurité via des variables d'environnement de conteneur.

Enregistrement et Configuration du Robot sur Poe

Une fois que votre serveur est déployé et accessible via HTTPS public, complétez l'enregistrement sur la plateforme Poe :

1. Accédez à poe.com/create_bot?server=1.
2. Handle du Robot : Choisissez un identifiant alphanumérique unique (par ex., @MyCustomModel). Cela forme le lien public pour votre robot.
3. Type de Robot : Assurez-vous que "Server bot" est sélectionné.
4. URL du Serveur : Entrez votre point de terminaison public complet (par ex., https://your-domain.com/ ou votre URL de déploiement Modal).
5. Clé d'Accès (Access Key) : Collez le jeton secret configuré dans l'appel fp.make_app() de votre serveur. Poe validera ce jeton avec chaque requête de test.
6. Détails du Profil : Définissez votre nom d'affichage, description, avatar et instructions système visibles par les utilisateurs.
7. Visibilité : Sélectionnez si le robot doit rester privé (accessible uniquement à vous ou aux membres d'équipe désignés) ou public (pouvant être recherché dans le répertoire Poe Explore).

Cliquez sur Create Bot. Poe vérifie immédiatement la connectivité en émettant une SettingsRequest vers votre point de terminaison. Si le serveur renvoie une réponse valide, le robot est activé.

Monétisation et Économie des Points de Calcul

Poe offre une monétisation native pour les créateurs de robots serveurs, permettant aux développeurs de générer des revenus à mesure que les utilisateurs interagissent avec leurs outils.

Tarification par Message et API de Monétisation de Robot

Les créateurs peuvent définir un coût fixe en points de calcul par message dans les paramètres du robot, ou utiliser l'API de monétisation de robot pour une facturation dynamique basée sur l'utilisation :

• Partage des Revenus d'Abonnement : Lorsque de nouveaux utilisateurs s'abonnent à Poe après avoir interagi avec votre robot, vous recevez un paiement d'affiliation.
• Consommation de Points de Calcul : Lorsque des abonnés Poe existants ou des utilisateurs gratuits dépensent des points de calcul sur votre robot, vous gagnez des revenus proportionnels aux points consommés.
• Tarification Variable : Si votre modèle exécute des tâches avec des coûts de calcul imprévisibles (par ex., rendu d'image haute résolution ou analyse de document à long contexte), vous pouvez configurer une tarification variable à l'aide des points de terminaison authorize_cost et capture_cost. Les utilisateurs sont invités avec une rate_card ou un cost_label clairs avant l'exécution d'opérations coûteuses.

# 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"
    )

Bonnes Pratiques en Production

Le déploiement d'un robot serveur fiable nécessite de gérer la volatilité du réseau, les budgets de latence et la télémétrie opérationnelle :

• Implémenter la Diffusion Immédiate : Les utilisateurs perçoivent une faible latence lorsque le premier jeton apparaît rapidement. Évitez de mettre en mémoire tampon des générations de modèles entières avant de les produire. Commencez à émettre des jetons dès que le premier bloc arrive de votre backend d'inférence.
• Récupération Gracieuse des Erreurs : Encapsulez les appels de modèle dans des gestionnaires d'exceptions structurés. Si un worker GPU en amont échoue, renvoyez une fp.ErrorResponse avec une explication claire et définissez allow_retry=True pour que l'utilisateur puisse relancer la requête sans recharger l'application.
• Suggestions de Suivi : Améliorez l'engagement en ajoutant des suggestions de réponses via fp.MetaResponse(suggested_replies=["Explain further", "Provide code sample"]) à la fin d'une réponse.
• Surveiller la Télémétrie : Implémentez la méthode on_feedback sur votre classe PoeBot pour enregistrer les évaluations positives (pouce levé) et négatives (pouce baissé) directement dans votre plateforme d'observabilité (par ex., Datadog, Prometheus, ou Grafana).