Combien de lignes dois-je modifier ?

Deux dans la configuration du client : l'URL de base et la clé API, plus le nom du modèle dans vos requêtes. Le format des messages et l'analyse des réponses restent identiques.

Est-ce vraiment ChatGPT sans filtre ?

Non. Il s'agit d'un modèle à poids ouverts différent, hébergé par un fournisseur indépendant et non affilié à OpenAI. Il est optimisé pour répondre sans refus de contenu pour un usage adulte légal.

Puis-je continuer à utiliser LangChain ou un autre framework ?

Oui, tant qu'il vous permet de définir une URL de base OpenAI-compatible. Définissez l'URL de base, la clé et l'ID du modèle uncensored.

Que perd-on en changeant ?

Tout ce qui n'est pas du texte : images, audio, embeddings et fine-tuning ne sont pas proposés. Vous n'avez accès qu'à un seul modèle, et non à un menu.

Alternative à ChatGPT sans filtre : passez en deux lignes

Avant et après

Voici un client OpenAI typique en Python :

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

r = client.chat.completions.create(
    model="your-current-model",
    messages=[{"role": "user", "content": "Draft a tense dialogue between two rivals."}],
)

Et le même client pointant vers l'alternative sans filtre :

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.chatgptunfiltered.com/v1",
    api_key=os.environ["UNFILTERED_API_KEY"],
)

r = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Draft a tense dialogue between two rivals."}],
)

Deux lignes changées dans le constructeur, et la chaîne du modèle changée dans l'appel. Le format des messages, l'objet de réponse et la façon de lire r.choices[0].message.content restent identiques. L'alternative est un modèle différent hébergé par un fournisseur indépendant. Ce n'est ni ChatGPT ni une API officielle d'OpenAI ou d'un autre.

Changement uniquement avec des variables d'environnement

Les versions récentes des SDK Python et Node officiels lisent OPENAI_BASE_URL et OPENAI_API_KEY lorsque vous créez un client sans arguments. Cela signifie que le code de l'application peut rester inchangé :

export OPENAI_BASE_URL="https://api.chatgptunfiltered.com/v1"
export OPENAI_API_KEY="YOUR_KEY"
python app.py

Vous devez toujours vous assurer que le code passe model="uncensored". Si le nom du modèle est codé en dur à de nombreux endroits, extrayez-le dans une valeur de configuration. Cette petite refactorisation rend tout changement futur aussi peu coûteux, dans les deux sens.

La même idée fonctionne en Node :

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.chatgptunfiltered.com/v1",
  apiKey: process.env.UNFILTERED_API_KEY,
});

const r = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Give me five villain names." }],
});
console.log(r.choices[0].message.content);

Frameworks et format des réponses

Les bibliothèques qui enveloppent le client OpenAI exposent généralement un paramètre d'URL de base. Dans l'adaptateur de chat OpenAI de LangChain, cela ressemble à ceci :

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.chatgptunfiltered.com/v1",
    api_key="YOUR_KEY",
)
print(llm.invoke("Name three moods for a chase scene.").content)

Si vous utilisez le format Responses plus récent, POST /v1/responses est pris en charge ainsi que POST /v1/chat/completions. GET /v1/models liste le modèle, ce qui est une vérification rapide que votre clé et votre URL sont corrects.

Différences à anticiper

Domaine	Ce que vous remarquerez
Volonté de répondre	Il répond sans refus de contenu pour un usage adulte légal. Les prompts qu'un modèle filtré refusera obtiendront généralement une réponse.
Formulation et style	Modèle différent, voix différente. Le ton, la longueur et les habitudes de formatage ne correspondront pas à votre modèle précédent.
Choix du modèle	Un seul modèle, ID `uncensored`. Pas de niveaux à choisir.
Portée	Texte uniquement : pas de génération d'images, audio ou vidéo, pas d'embeddings, pas de fine-tuning.
Contexte	100 000 tokens, prompt plus complétion. `max_tokens` est optionnel.
Limites	Clé complète : 8 concurrentes, 300 par minute. Clé d'essai : 2 concurrentes, 60 par minute. Corps jusqu'à 8 Mo.
Erreurs	HTTP 429 avec code `rate_limited` ou `concurrency` ; une surcharge temporaire renvoie 429 avec `Retry-After: 5`.

Le streaming, l'appel de fonctions et le mode JSON sont pris en charge, ainsi que temperature, top_p, stop, seed et les pénalités. Les en-têtes de réponse incluent X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests et X-RateLimit-Limit-Concurrency. La documentation contient les détails.

Deux différences supplémentaires méritent une ligne. Premièrement, un modèle différent peut compter les tokens différemment, donc les comptes pour le même texte peuvent différer de ce que votre ancien fournisseur rapporte ; utilisez les chiffres d'utilisation dans les réponses, pas vos propres estimations. Deuxièmement, les fonctionnalités qui dépendent d'outils hébergés par un fournisseur, comme la recherche web intégrée ou le stockage de fichiers côté fournisseur, ne font pas partie de ce service. L'appel de fonctions est : vous définissez des fonctions, et votre code les exécute.

Un script de parité pour vos propres prompts

Au lieu d'observer à l'œil nu quelques sorties, exécutez votre ensemble de prompts via le nouvel endpoint dans une boucle et sauvegardez tout ce dont vous avez besoin pour examiner.

import csv, json

with open("prompts.json", encoding="utf-8") as f:
    prompts = json.load(f)  # a list of strings

with open("results.csv", "w", newline="", encoding="utf-8") as out:
    w = csv.writer(out)
    w.writerow(["prompt", "reply", "in_tokens", "out_tokens"])
    for p in prompts:
        r = client.chat.completions.create(
            model="uncensored",
            temperature=0.7,
            messages=[{"role": "user", "content": p}],
        )
        w.writerow([p, r.choices[0].message.content, r.usage.prompt_tokens, r.usage.completion_tokens])

Ouvrez le CSV et examinez une colonne à la fois. Les colonnes de tokens vous donnent une estimation des coûts pour le même trafic : multipliez les sommes par $0,15 et $0,50 par 1M. Une clé d'essai permet 60 requêtes par minute et 2 à la fois, donc un ensemble de quelques centaines de prompts se termine en quelques minutes si vous gardez la boucle séquentielle.

Une courte liste de contrôle de migration

Obtenez une clé. Sur la page des clés API, connectez-vous avec Google ou e-mail et réclamez le crédit d'essai gratuit de $0,50. Il dure 7 jours et ne nécessite pas de carte.
Mettez le nom du modèle et l'URL dans la configuration. Un seul endroit, lu depuis l'environnement.
Relancez vos prompts de test. Utilisez 20 à 50 exemples réels, y compris ceux que votre modèle précédent a refusés, et lisez les résultats.
Ajustez le prompt système. Supprimez le texte qui n'existait que pour convaincre un modèle filtré de répondre. Gardez ce qui décrit le rôle, le public et le format.
Ajoutez un gestionnaire 429. Attendez 5 secondes et réessayez. Limitez le parallélisme pour correspondre à votre clé.
Vérifiez l'utilisation. Surveillez X-Balance-USD sur les réponses pendant que vous faites tourner un trafic réel.

Un helper de retry qui couvre l'étape 5 :

import time
from openai import RateLimitError

def create_with_retry(**kwargs):
    for _ in range(4):
        try:
            return client.chat.completions.create(**kwargs)
        except RateLimitError:
            time.sleep(5)
    raise RuntimeError("rate limited after 4 tries")

Conservez les sorties sauvegardées de l'ancien modèle pendant quelques semaines. Si un utilisateur se plaint que quelque chose semble étrange après le changement, vous pouvez comparer avec ce que l'ancien modèle aurait dit et voir si la différence vient du prompt, du modèle ou de l'entrée.

Déploiement sans risque

Ne basculez pas tout d'un coup. Placez le choix du fournisseur derrière une configuration pour pouvoir déplacer un pourcentage du trafic et revenir en arrière en quelques secondes.

import os, random
from openai import OpenAI

old = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
new = OpenAI(base_url="https://api.chatgptunfiltered.com/v1", api_key=os.environ["UNFILTERED_API_KEY"])

SHARE = float(os.environ.get("NEW_SHARE", "0.05"))

def pick():
    if random.random() < SHARE:
        return new, "uncensored"
    return old, os.environ["OLD_MODEL"]

Commencez à 5 %, surveillez votre taux d'erreur, le nombre de réponses 429 et les retours utilisateurs pendant quelques jours, puis augmentez-le. Définissez NEW_SHARE à 0 pour revenir en arrière. Choisir par utilisateur ou par fonctionnalité est préférable à choisir par requête lorsque les conversations doivent rester sur un seul modèle, car changer de modèle en cours de conversation modifie la voix.

Ce que cela coûte, et quand rester en place

La tarification est de $0,15 par 1M de tokens d'entrée et $0,50 par 1M de tokens de sortie, depuis le crédit prépayé. Une requête avec 1 500 tokens en entrée et 400 en sortie coûte 1 500 x $0,15 / 1M = $0,000225, plus 400 x $0,50 / 1M = $0,0002, soit $0,000425, ou $0,425 par 1 000 requêtes. Pour d'autres fournisseurs, consultez leurs pages de tarification actuelles ; les tarifs changent et une comparaison de mémoire devient vite obsolète. Les recharges sont des montants entiers de $20 à $500, payés en crypto, avec des bonus à partir de $50. Détails sur les tarifs.

Rester avec votre fournisseur actuel est le bon choix si vous avez besoin d'images ou d'embeddings, si votre audience nécessite une modération stricte, ou si un modèle spécifique au fournisseur est une exigence dure. Pour comprendre ce qu'est cette classe de modèles, lisez comprendre les modèles ChatGPT sans censure. La limite dure ne change jamais : tout contenu sexuel impliquant des mineurs est interdit.

Il est également acceptable d'exécuter les deux fournisseurs côte à côte. De nombreuses équipes acheminent les requêtes ordinaires vers un modèle et les requêtes qui continuent de déclencher des refus vers un autre. Comme les deux utilisent le même format, ce routage nécessite quelques lignes de code et une règle indiquant quand utiliser lequel.