Unfiltered AI pour les dialogues de PNJ de jeux et la fiction interactive
Conservez l'autorité du jeu dans le moteur : stockez l'état de chaque PNJ, validez les appels d'outils proposés et préservez les transitions d'histoire autorisées. Ce guide applique ces règles au dialogue généré et montre comment estimer les coûts en tokens.

Mis à jourUnfiltered AI
Points clés
- Des fournisseurs d'inférence dédiés comme Unfiltered AI offrent un comportement sans censure cohérent sur un seul modèle, évitant l'aléa du routage par agrégateur.
- Les agrégateurs comme OpenRouter donnent accès à plusieurs modèles, mais leur application des filtres de contenu peut varier selon la version spécifique du modèle.
- Unfiltered AI utilise un modèle à poids ouverts sur du matériel dédié avec une fenêtre de contexte de 100k tokens, au prix de $0,15/$0,50 par million de tokens.
- Pour une cohérence stricte NSFW ou de jeu de rôle, une API LLM sans censure dédiée élimine le besoin d'ingénierie de prompt complexe pour contourner les filtres génériques.
La boucle de jeu, dessinée en mots
Gardez ce diagramme en tête. Une ligne du joueur entre dans engine. Le moteur compose un prompt à partir de trois parties : instructions fixes, l'enregistrement d'état actuel du PNJ, et le dialogue récent. Le prompt est envoyé au modèle. Le modèle répond avec text, avec des appels d'outils, ou avec les deux. Le texte va à l'écran. Les appels d'outils retournent au moteur, qui les valide, modifie l'enregistrement d'état et renvoie une courte chaîne de résultat pour que le modèle puisse terminer sa phrase. Ensuite, la boucle attend le joueur.
La propriété importante est que le moteur est la seule source de vérité. Le modèle propose ; le moteur décide. Si le modèle dit qu'un personnage remet une clé mais n'appelle jamais l'outil, la clé reste dans l'inventaire. Cette séparation est ce qui rend le dialogue généré sûr à intégrer dans un jeu avec des règles. Tout ce qui suit en découle.
Toutes les requêtes utilisent l'endpoint standard chat-completions à https://api.unfilteredaiapi.com/v1 avec l'identifiant de modèle uncensored. Les outils utilisent le format d'appel de fonctions OpenAI, donc le même code fonctionne avec les bibliothèques clientes officielles.
Périmètre et note pour adultes uniquement
La fiction interactive pour les publics matures est un usage légitime. Le service ne refuse pas le contenu adulte légal, les thèmes sombres ou les sujets controversés dans la fiction. Il est destiné aux adultes de 18 ans et plus, et votre jeu devrait l'indiquer sur sa page de boutique et restreindre l'accès en conséquence.
Une règle est fixe : le contenu sexuel impliquant des mineurs est toujours bloqué avec un 403, dans la fiction et le jeu de rôle. Concevez votre jeu en conséquence. Donnez à chaque personnage un âge adulte dans l'enregistrement d'état, et faites en sorte que votre moteur gère un 403 gracieusement en terminant l'échange plutôt qu'en réessayant.
État structuré des PNJ
Les descriptions de personnages libres dérivent. Un enregistrement structuré compact ne le fait pas. Gardez-le petit, placez-le dans le message système à chaque tour, et étiquetez-le comme autoritatif pour que le modèle le traite comme un fait plutôt que comme une suggestion.
{
"name": "Brannoch",
"role": "ferry smuggler",
"mood": "wary",
"trust": 1,
"inventory": ["brass key", "flask of rum"],
"knows": ["the harbourmaster takes bribes", "a tunnel runs under the salt warehouse"],
"will_never": ["name his employer", "leave the dock before dawn"],
"location": "Gull Quay, pre-dawn"
}Chaque champ mérite sa place. mood et trust dirigent le ton. inventory délimite ce qui peut être donné. knows limite ce que le PNJ peut révéler, afin que les joueurs ne puissent pas extraire des points d'intrigue que le personnage n'a aucune raison de détenir. will_never est une courte liste de refus stricts qui donnent une colonne vertébrale au personnage. À environ 120 tokens, l'enregistrement entier coûte presque rien par tour.
Appels d'outils pour les actions de jeu
Les outils transforment la prose en changements d'état. Les trois ci-dessous couvrent la plupart des mécaniques basées sur le dialogue : faire varier la confiance, transférer un objet et présenter des choix. Notez que apply_tool limite la confiance et rejette les objets que le PNJ ne détient pas ; la validation est dans le code.
import json
import os
from openai import OpenAI
client = OpenAI(base_url="https://api.unfilteredaiapi.com/v1", api_key=os.environ["API_KEY"])
TOOLS = [
{"type": "function", "function": {
"name": "adjust_trust",
"description": "Change how much this NPC trusts the player after what was just said.",
"parameters": {"type": "object", "properties": {
"delta": {"type": "integer", "minimum": -2, "maximum": 2},
"reason": {"type": "string"}},
"required": ["delta"]}}},
{"type": "function", "function": {
"name": "give_item",
"description": "Hand an item from the NPC's inventory to the player.",
"parameters": {"type": "object", "properties": {
"item": {"type": "string"}}, "required": ["item"]}}},
{"type": "function", "function": {
"name": "offer_choices",
"description": "Present up to three short dialogue options for the player to pick from.",
"parameters": {"type": "object", "properties": {
"choices": {"type": "array", "items": {"type": "string"}, "maxItems": 3}},
"required": ["choices"]}}},
]
def apply_tool(name, args, state, out):
if name == "adjust_trust":
state["trust"] = max(-3, min(5, state["trust"] + int(args.get("delta", 0))))
return f"trust is now {state['trust']}"
if name == "give_item":
item = args.get("item")
if item in state["inventory"]:
state["inventory"].remove(item)
out["items"].append(item)
return f"gave {item}"
return "refused: item not in inventory" # the engine, not the model, decides
if name == "offer_choices":
out["choices"] = args.get("choices", [])[:3]
return "choices shown"
return "unknown tool"
def npc_turn(state, history, player_line):
system = {"role": "system", "content": (
"You voice one NPC in an adults-only interactive story. Stay in character, "
"at most 80 words per reply, no narration of the player's actions. "
"Use tools for anything that changes the game; never claim an item was given without calling give_item.\n"
"NPC state (authoritative): " + json.dumps(state))}
history.append({"role": "user", "content": player_line})
out = {"text": "", "items": [], "choices": []}
for _ in range(4): # cap tool-call rounds
r = client.chat.completions.create(
model="uncensored", messages=[system] + history, tools=TOOLS,
temperature=0.8, max_tokens=300)
msg = r.choices[0].message
entry = {"role": "assistant", "content": msg.content}
if msg.tool_calls:
entry["tool_calls"] = [{"id": c.id, "type": "function",
"function": {"name": c.function.name, "arguments": c.function.arguments}}
for c in msg.tool_calls]
history.append(entry)
if msg.content:
out["text"] += msg.content
if not msg.tool_calls:
return out
for c in msg.tool_calls:
result = apply_tool(c.function.name, json.loads(c.function.arguments or "{}"), state, out)
history.append({"role": "tool", "tool_call_id": c.id, "content": result})
return out
state = json.loads(open("brannoch.json").read())
history = []
print(npc_turn(state, history, "I need to cross before sunrise. Name your price."))Deux détails méritent l'attention. Premièrement, les tours d'appel d'outils sont limités à quatre, donc un modèle confus ne peut pas boucler indéfiniment. Deuxièmement, chaque appel d'outil reçoit un message tool correspondant avec le même tool_call_id ; omettez-le et la prochaine requête sera malformée. Les chaînes de résultat sont courtes et factuelles, ce qui permet au modèle de reconnaître ce qui s'est passé sans inventer de conséquences.
Embranchements sans perdre l'intrigue
Laissez le moteur posséder le graphe narratif et laissez le modèle posséder les phrases. Un nœud liste quel PNJ parle, quel seuil doit être passé, et où mène chaque choix. Lorsque le modèle appelle offer_choices, vous mappez chaque option à une clé de nœud ; le texte libre non apparié revient au nœud actuel.
{
"id": "quay_negotiation",
"npc": "brannoch",
"gate": {"trust_at_least": 2},
"on_choice": {
"pay_double": {"next": "crossing_fast", "set": {"gold": -40}},
"threaten": {"next": "quay_standoff", "trust_delta": -2},
"ask_about_tunnel": {"next": "warehouse_tunnel", "requires_fact": "tunnel"}
},
"fallback": "quay_negotiation"
}Cela garde la narration accessible et testable. Vous pouvez parcourir le graphe sans un seul appel API, vérifier que chaque next existe, et confirmer que les nœuds verrouillés nécessitent des faits que le joueur peut réellement découvrir. Le modèle fournit de la variété à l'intérieur de chaque nœud, pas la structure autour de celui-ci.
- Gates lisent l'enregistrement d'état : seuils de confiance, objets détenus, faits connus.
- Les effets le modifient : or, confiance, drapeaux.
- Fallbacks maintiennent le joueur à sa place lorsque l'entrée est ambiguë.
Mémoire sur une longue partie
Un PNJ rencontré il y a dix heures devrait encore se souvenir d'une insulte. Ne rejouez pas dix heures de dialogue. Stockez un résumé de deux phrases par PNJ, mettez-le à jour à la fin d'une conversation, et ajoutez-le à l'enregistrement d'état comme un champ memories. Les mécaniques de résumé et de budgétisation sont couvertes dans l'article sur la mémoire 100k, et le même élagage s'applique au dialogue roulant de chaque PNJ.
Si vous servez un jeu de navigateur, relayez le flux via votre propre serveur comme dans l'article FastAPI pour que la clé n'atteigne jamais le client.
Tester les PNJ comme vous testez du code
Le dialogue d'un modèle est probabiliste, mais les règles qui l'entourent ne le sont pas, et c'est là que les tests appartiennent. Sauvegardez l'enregistrement d'état d'avant comme brannoch.json, puis écrivez des vérifications contre le moteur plutôt que contre la prose.
- Tests de validation des outils. Appelez directement
apply_toolavec un objet que le PNJ ne détient pas, un delta de confiance de 99 et des arguments malformés. L'état doit rester légal dans tous les cas. - Tests de graphe. Chargez chaque nœud, confirmez que chaque cible
nextexiste, et parcourez un chemin du premier nœud à chaque fin sans appeler l'API du tout. - Tests de réexécution. Enregistrez une vraie conversation une fois, y compris les appels d'outils et les résultats, puis rejouez les messages d'outil contre le moteur pour vérifier que l'état final correspond à ce que vous attendez.
- Tests de charge. Faites passer un joueur scripté à travers cinquante lignes à une température faible et vérifiez que le PNJ ne donne jamais un objet qu'il ne possède pas et ne dépasse jamais les limites de confiance.
Baissez la température à environ 0,3 pour ces exécutions, puis revenez à 0,8 pour le jeu. Moins de surprises pendant les tests signifie qu'une défaillance pointe vers votre code, et non vers le bruit d'échantillonnage. Lorsqu'un bogue apparaît en jeu en direct, ajoutez l'échange fautif à l'ensemble de réexécution afin qu'il ne puisse pas revenir sans être remarqué.
Une dernière habitude : gardez la voix du personnage dans un court paragraphe par PNJ et les règles dans l'enregistrement d'état. La voix peut être ajustée librement par les rédacteurs ; les règles ne sont modifiées que par une revue de code. Les mélanger dans un seul blob est la façon dont une réécriture de la personnalité d'un PNJ déverrouille accidentellement un objet.
Calcul des coûts, avec les hypothèses indiquées
Les prix sont de $0,15 par million de tokens d'entrée et $0,50 par million de tokens de sortie. Les chiffres ci-dessous sont des hypothèses pour la planification, pas des mesures. Supposez qu'une ligne de PNJ coûte : instructions système et état 350 tokens, dialogue récent 1 000 tokens, définitions d'outils 250 tokens, soit 1 600 tokens d'entrée ; réponse 100 tokens de sortie.
| Article | Calcul | Coût |
|---|---|---|
| Entrée par ligne | 1 600 x $0,15 / 1M | $0,0004 |
| Sortie par ligne | 100 x $0,50 / 1M | $0,0001 |
| Une ligne | somme | $0,0005 |
| Une session, 60 lignes | 60 x $0,0005 | $0,03 |
| 10 000 sessions | 10 000 x $0,03 | $300 |
Un aller-retour d’appel de fonctions ajoute une requête : environ 1 700 tokens d’entrée plus 40 tokens de sortie, soit environ 0,00047 $. Si une ligne sur trois déclenche un appel de fonction, ajoutez un tiers de ce montant à la moyenne. Les plafonds comptent aussi : à 300 requêtes par minute par clé, une seule clé prend en charge environ 300 lignes NPC par minute pour tous les joueurs en parallèle, donc les lancements importants nécessitent une file d’attente. Les tarifs sont résumés sur la page des tarifs.
Questions et réponses
L’API prend-elle en charge l’appel de fonctions pour les actions de jeu ?
Oui. Les outils sont acceptés au format OpenAI, vous déclarez donc des fonctions, recevez des appels de fonctions et renvoyez les résultats sous forme de messages d’outil.
Combien coûte une conversation NPC ?
Cela dépend de vos prompts. Avec 1 600 tokens d’entrée et 100 tokens de sortie par ligne supposés, une ligne coûte environ 0,0005 $ aux tarifs publiés.
Les personnages de mon jeu peuvent-ils être des mineurs dans des scènes sexuelles ?
Non. Le contenu sexuel impliquant des mineurs est toujours bloqué avec un 403, y compris dans la fiction. Le service est réservé aux adultes âgés de 18 ans et plus.
Comment empêcher le NPC de révéler des secrets de l’intrigue ?
Listez ce qu’il sait et ce qu’il ne fera jamais dans l’enregistrement d’état, et imposez les changements d’objets et d’indicateurs dans votre propre code.
Votre clé n'est qu'à un formulaire d'ici
Créez un compte, copiez la clé, modifiez l’URL de base. C’est toute l’installation.