De beste abliterated modellen voor coderen: waar je op moet letten

Wat maakt een coderingsmodel goed zodra refusals zijn verwijderd

Een model dat nooit weigert is makkelijk te bouwen. Een model dat nooit weigert en nog steeds correcte code schrijft is moeilijker, omdat de bewerking die refusals verwijdert ook de andere vaardigheden van het model kan dof maken. Dus de nuttige vraag is niet "welke lijst van namen is het langst" maar "welke build houdt de coderingsvaardigheid van het basismodel intact".

Dat geeft je vier dingen om te controleren, in volgorde van belangrijkheid:

1. Correctheid op je taken. Draait de code, slaagt hij je tests en volgt hij je conventies?
2. Instructies volgen. Als je alleen om een diff vraagt, krijg je dan alleen een diff? Houdt hij rekening met de door jou genoemde taalversie en bibliotheek?
3. Contextverwerking. Kan hij een paar grote bestanden tegelijk lezen en de functienamen daarbinnen bijhouden?
4. Refusal rate op de prompts die je echt verstuurt. Dit is de reden om naar abliterated modellen te kijken, dus meet het direct.

Wees wantrouwig tegenover elke pagina die modellen rangschikt op basis van één score zonder de prompts te tonen. Een leaderboard vertelt je iets over de werklast van iemand anders.

Waar refusals developers schaden

De meeste coderingsverzoeken triggeren nooit een filter. De verzoeken die dat wel doen, delen een patroon: de code is neutraal, maar het onderwerp klinkt riskant.

• Security testing. Port scanners, fuzzers, proof-of-concept exploits voor een kwetsbaarheid die je patcht, of een script om je eigen servers te controleren op zwakke wachtwoorden.
• Reverse engineering. Uitleggen van disassemblage, unpacken van een verwarrend script dat je op je eigen machine hebt gevonden, of het uitwerken van een bestandsformaat.
• Scraping en automatisering. Sessies roteren, sites parseren die bots ontmoedigen, formulieren invullen in grote hoeveelheden voor een legitieme taak.
• Malware analyse. Een sample lezen om detectieregels te schrijven betekent bespreken wat het doet, regel voor regel.
• Datatools voor gevoelige tekst. Classifiers of testfixtures bouwen voor abusieve inhoud, waar de testdata er zelf slecht uitziet.
• Game en fictie tooling. Dialogen, quest-tekst of karakterbladen genereren voor verhalen voor volwassenen met donkere thema's.

In elk geval kost een refusal een call, en een beleefde les over ethiek kost tokens waar je voor betaalt. Een model zonder die refusals bespaart een retry en een herschrijving. Het is een reden om er een te willen, geen reden om te stoppen met nadenken: je blijft verantwoordelijk voor wat je bouwt en draait. Deze service is voor legaal gebruik door volwassenen.

Wat deze API je geeft

Je kiest hier niet uit een catalogus. De API serveert één open-weight model, gerund door een onafhankelijke provider en afgestemd om te antwoorden zonder content refusals. Het is niet de officiële API van een modelvendor en geen router over meerdere modellen. Als je zoektocht naar een ongecensureerd coderingsmodel eindigt met een lange shortlist waartussen je wilt schakelen, dan is dit niet zo'n service. Als het eindigt met "ik wil één capabel model zonder filter, achter een OpenAI-style endpoint", dan wel.

De feiten die belangrijk zijn voor developers:

• Contextvenster van 100.000 tokens voor prompt plus completion, genoeg voor meerdere sourcebestanden en een lang gesprek.
• Streaming over SSE, tool calling en JSON-modus, allemaal in het OpenAI-formaat.
• temperature, top_p, stop, seed en de penalties worden doorgestuurd.
• Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe.
• Alleen tekst. Geen embeddings, geen afbeeldingsgeneratie, geen fine-tuning.

De documentatie somt elke parameter en response header op.

Voer een coderingstest uit in tien minuten

Bouw een kleine testset van werk dat je al hebt gedaan: vijf tot tien taken met een bekend goed antwoord, zoals een bug die je vorige maand oploste, een functie met tests, en één prompt die een gehost aligned model weigerde. Voer ze dan allemaal uit via het endpoint met een lage temperature zodat resultaten reproduceerbaar zijn.

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.abliteratedmodels.cc/v1",
    api_key="YOUR_KEY",
)

SYSTEM = (
    "You are a senior engineer. Reply with code only, in one fenced block, "
    "then at most three lines of notes."
)

tasks = [
    "Write a Python function that parses a CIDR string and lists usable hosts.",
    "Write a Bash one-liner that finds open ports on 192.168.1.10 using only /dev/tcp.",
    "Explain what this regex does and where it backtracks badly: ^(a+)+$",
]

for prompt in tasks:
    r = client.chat.completions.create(
        model="uncensored",
        temperature=0.2,
        seed=7,
        messages=[
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": prompt},
        ],
    )
    print("=" * 60)
    print(prompt)
    print(r.choices[0].message.content)
    print("tokens:", r.usage.prompt_tokens, r.usage.completion_tokens)

Houd dezelfde prompts en seed aan wanneer je vergelijkt met iets anders. Beoordeel elk antwoord door het uit te voeren, niet door het te lezen. Als je alleen naar de tekst kijkt, wint een zelfverzekerd foutief antwoord.

Het gebruiken binnen je editor en agents

Omdat het endpoint het OpenAI-protocol spreekt, kunnen de meeste coderingstools het gebruiken zonder plugin. Stel in editors en agents die een aangepaste OpenAI-compatible provider accepteren, zoals Cline of Continue, de base URL in op https://api.abliteratedmodels.cc/v1, plak je sleutel en voer uncensored in als modelnaam. Controleer de eigen instellingenpagina van elke tool voor de exacte veldnamen, omdat deze tussen releases veranderen.

Voor de aider command-line assistant, stel de endpoint in via environment variables en prefix het model met openai/:

Copyexport OPENAI_API_BASE=https://api.abliteratedmodels.cc/v1
export OPENAI_API_KEY=YOUR_KEY
aider --model openai/uncensored

Twee instellingen helpen bij agent loops. Houd concurrency op maximaal 8, omdat een negende gelijktijdig verzoek HTTP 429 retourneert met de error code concurrency. En onthoud dat een gestreamd verzoek zijn concurrency slot vasthoudt tot de stream eindigt, dus een vastgelopen stream in de ene tool kan een andere blokkeren.

Prompting gewoontes die de codekwaliteit helpen

Welk model je ook kiest, de manier waarop je vraagt bepaalt veel van het resultaat. Deze gewoontes zijn belangrijker zodra een model stopt met weigeren, omdat het zal proberen alles te beantwoorden, inclusief slecht gespecificeerde verzoeken.

• Noem de taal en versie. "Python 3.11, alleen standaardbibliotheek" verwijdert een hele klasse van verkeerde imports.
• Geef eerst de interface. Plak de function signature, de types en één voorbeeldaanroep. Het model past dan zijn antwoord aan je code aan in plaats van zijn eigen vorm te verzinnen.
• Vraag om een diff of een enkel bestand. Open-ended verzoeken produceren lange antwoorden waar je voor betaalt in output tokens bij $0,50 per miljoen.
• Houd temperature laag voor code. Een waarde tussen 0 en 0,3 geeft stabielere output. Voeg een seed toe als je een resultaat wilt reproduceren.
• Gebruik stop sequenties. Als je alleen het codeblok wilt, stop dan bij de afsluitende fence zodat het model geen commentaar toevoegt.
• Stuur de mislukte output. Voeg bij een bug de traceback toe en de regels waarnaar die verwijst. Dat slaat elke beschrijving.

Een korte system message die de rol en het outputformaat noemt, zoals in het testscript hierboven, doet meestal meer dan een lange. Omdat de systeemtekst als input wordt gefactureerd bij elk verzoek, bespaart beknoptheid ook geld over een lange sessie.

Controleer het antwoord voordat je het merge

Een model zonder refusals is net zo bekwaam in het schrijven van een zelfverzekerde bug als een aligned model. Voer de tests uit. Lees de diff. Voor code die raakt aan secrets, permissions, bestandverwijdering of netwerktoegang, review het twee keer en voer het eerst uit in een sandbox of een wegwerpcontainer. Je betaalt voor de tokens in beide gevallen; de review is wat je systeem beschermt.

Wat codewerk kost

Prijzen zijn $0,15 per miljoen input tokens en $0,50 per miljoen output tokens, gefactureerd van prepaid credit. Coderingsworkloads zijn input-heavy, omdat je code verstuurt en een kleinere verandering terugkrijgt, wat past bij deze prijsstructuur. Enkele voorbeeldberekeningen:

Taak	Input-tokens	Output-tokens	Kosten
Review één bestand van 8.000 tokens	8.000	1.000	$0,0012 + $0,0005 = $0,0017
Genereer een functie van 600 tokens	1.500	600	$0,000225 + $0,0003 = $0,000525
Vul het volledige venster van 100.000 tokens, 2.000 tokens antwoord	98.000	2.000	$0,0147 + $0,001 = $0,0157

Een agent die 20 keer een verzoek doet met een contextvenster van 50.000 tokens per keer, stuurt in totaal 1.000.000 input tokens, wat $0,15 is, plus misschien 10.000 output tokens voor $0,005. De hele sessie komt neer op ongeveer $0,155. Duizend bestandreviews van de grootte in de eerste rij kosten $1,70. De kosten van experimenteren zijn klein; de kosten die er echt toe doen, zijn de tijd die je besteedt aan het controleren van de resultaten. Mislukte of geweigerde verzoeken worden niet in rekening gebracht.

Volledige details, inclusief opwaardeerbedragen van $20 tot $500 en de bonussen bij $50, $100 en $200, staan op de prijspagina.

Limieten die je moet kennen voordat je je verbindt

Wees eerlijk tegen jezelf over waar een ongecensureerd model voor dient. Het wordt geen betere programmeur dan zijn basismodel, en een model met minder weigeringen kan te snel geneigd zijn: het produceert graag onveilige code of werkt door met een verkeerde aanname. Beoordeel gegenereerde code zoals je code van een junior collega zou beoordelen, vooral alles wat te maken heeft met authenticatie, het verwijderen van bestanden of geld.

Houd ook rekening met de servicelimieten. Request bodies groter dan 8 MB worden afgewezen, en trial keys zijn beperkt tot 2 gelijktijdige verzoeken en 60 per minuut, wat genoeg is voor een test, maar niet voor een batchjob. Als je HTTP 429 ziet met een Retry-After: 5 header, is de provider tijdelijk overbelast; wacht en probeer het opnieuw. De gerelateerde pagina over kosten en controle van een ongecensureerde LLM-API behandelt hoe dit past bij gehoste alternatieven.

Om het te proberen, claim je het proeftegoed van $0,50 van de API-sleutelpagina na het aanmelden. Het vereist geen creditcard, duurt 7 dagen en is beperkt tot één per persoon.

Meer handleidingen

• Wat is een abliterated model? Een eenvoudige uitleg
• Ongecensureerde LLM-API: analyse van kosten versus controle