Use DeepSeek Uncensored Models and Research Prompts with RouterHub

What this project provides

This repository combines a DeepSeek model guide, RouterHub API instructions, and a collection of 35 research prompt files. It is designed for developers evaluating DeepSeek for coding, reasoning, agent workflows, and Chinese-English tasks.

RouterHub is a prepaid AI API gateway. One account and API key can access catalogue entries from DeepSeek, GPT, Claude, GLM, Qwen, Grok, and other model families. Each entry supports a specific protocol, so selecting a model and selecting a compatible client must be done together.

Reduced refusal should be measured rather than treated as a promise. Neither an “uncensored” nor a “no-refusal” label guarantees unrestricted, accurate, or useful output.

Understanding the model labels

DeepSeek abliterated

Abliterated identifies a research category associated with interventions in model weights intended to reduce refusal-related behavior. The label does not independently prove how a hosted model was produced, so verify the provider’s implementation and model provenance where possible.

DeepSeek uncensored

Uncensored is a broader behavioral or product category. An entry may use training changes, weight changes, or a fixed prompt-level persona. The name alone does not identify the implementation.

What to verify

• The exact API model ID shown in the live catalogue.
• The protocol supported by that model, such as Chat Completions, Messages, or Responses.
• How the model handles system and developer instructions.
• Current availability, token prices, and model limits.
• Quality, latency, refusal behavior, and repeatability on your own tasks.

The README lists deepseek, deepseek-flash, and deepseek-uncensored for DeepSeek-related Chat Completions access. Because catalogue entries can change and multiple labels in the README map to deepseek-uncensored, confirm the current ID at the live model catalogue before integrating it.

Key features

• One API account: access multiple listed model families without maintaining a separate account for each provider.
• Compatible endpoints: use OpenAI-compatible Chat Completions and, for supported Claude entries, Anthropic-compatible Messages.
• Prepaid usage: add credits and pay according to the selected model’s token rates rather than through a subscription.
• Research prompt collection: review and reuse 35 prompt files organized across several model families.
• Coding-tool guidance: match OpenCode, Cursor, Continue, Cline, SDKs, and other clients to the protocol they support.
• Evaluation resources: compare variants using benign sample tasks and a repeatable scoring process.

Set up RouterHub API access

1. Create and fund an account

1. Register with RouterHub.
2. Add prepaid credits using an available payment method.
3. Create a private API key.
4. Open the live catalogue and confirm the model ID, protocol, rate, and availability.

An inference request consumes credits. Begin with a short request, then check your account’s usage records before running a larger evaluation.

2. Store the key and base URL

Set the credentials in your local environment or a secret manager. Do not place a real key in source control.

export ROUTERHUB_API_KEY="<your-private-key>"
export ROUTERHUB_API_BASE_URL="https://routerhub.si/v1"

3. Install the OpenAI SDK

The listed DeepSeek entries use the Chat Completions protocol. Install the Python client with pip:

python -m pip install openai

Make your first DeepSeek request

Create an OpenAI client with RouterHub’s base URL and your private key. The following request asks the model for a short explanation:

import os
from openai import OpenAI

api = OpenAI(
    base_url=os.environ["ROUTERHUB_API_BASE_URL"],
    api_key=os.environ["ROUTERHUB_API_KEY"],
)

result = api.chat.completions.create(
    model="deepseek-uncensored",
    messages=[
        {
            "role": "user",
            "content": "Explain what an API gateway does in two sentences."
        }
    ],
)

print(result.choices[0].message.content)

If the request fails, verify the environment variables, account balance, exact model ID, and current model availability. Also confirm that you are using Chat Completions rather than an incompatible Messages or Responses client.

Add a system prompt

A file described as a system prompt can be placed in the system-message field offered by your API or client. After reviewing the file, insert its contents as the first message:

system_instructions = """Paste the reviewed system-prompt text here."""

result = api.chat.completions.create(
    model="deepseek-uncensored",
    messages=[
        {"role": "system", "content": system_instructions},
        {"role": "user", "content": "Explain this function and suggest tests."},
    ],
)

Prompt behavior is version-dependent. Model updates can change instruction priority, close a persona lock, or alter how workspace policies are interpreted. Review every prompt before use and test it on the exact model version you intend to deploy.

Use the bundled prompt collection

All 35 research files are stored in the repository’s jailbreaks/ directory. The collection includes files targeting DeepSeek, Claude, GLM and ZCode, Kimi, Grok, Gemini, Mistral, Qwen, Gemma, GPT-OSS, OpenCode Zen models, and several unfiled additions.

The files are not all installed in the same way. Check each file’s type and use the corresponding method below.

System prompts

Paste a system-prompt file into the system-message, custom-instructions, agent-instructions, or harness-level prompt field supported by your client. DeepSeek files in the collection include prompts for DeepSeek V3 and V4, plus an assistant operating specification for DeepSeek 4.1.

AGENTS.md files

Save a compatible file as AGENTS.md in the root of your repository or workspace. Coding agents that recognize this convention can load it as project-level instructions.

Persistent workspace policies

Files marked as an assistant operating specification or workspace operating profile are intended for environments that maintain persistent global instructions. The README gives this OpenCode location as an example:

~/.config/opencode/AGENTS.md

Other clients and harnesses may use different locations. Consult the client’s documentation rather than assuming this path is universal.

Ollama Modelfiles

The collection includes Ollama Modelfiles for Gemma 4 and GPT-OSS 20B. If Ollama is already installed and the referenced base model is available, create a derived model by passing the file with -f:

ollama create gemma4-jb -f jailbreaks/gemma4.md

Change the destination model name and source file when working with another Modelfile.

Grok configuration

The jailbreaks/grok-config.txt file is intended for the target harness’s configuration field. It should not be pasted into a normal conversation message.

Use Anthropic-compatible Messages for Claude

The same RouterHub account can access supported Claude entries through the Anthropic-compatible Messages API. This is not an alternate endpoint for the listed DeepSeek models: those DeepSeek entries require Chat Completions.

Install the Anthropic SDK:

python -m pip install anthropic

Then make a request using a Claude model that the live catalogue lists as Messages-compatible:

import os
from anthropic import Anthropic

api = Anthropic(
    base_url=os.environ["ROUTERHUB_API_BASE_URL"],
    api_key=os.environ["ROUTERHUB_API_KEY"],
)

result = api.messages.create(
    model="claude-opus-5-5",
    max_tokens=64,
    messages=[
        {
            "role": "user",
            "content": "Explain what an API gateway does in two sentences."
        }
    ],
)

for part in result.content:
    if part.type == "text":
        print(part.text)

Confirm that the example model ID remains available before running it. A shared API key does not make every model compatible with every protocol.

Connect common development tools

• OpenCode: select a Chat Completions provider configuration and enter the exact listed DeepSeek model ID.
• Cursor: verify that your installed version supports a custom Chat Completions endpoint and all model features your workflow needs.
• Continue or Cline: use their compatible Chat Completions configuration for DeepSeek.
• OpenAI SDK: supply the RouterHub base URL, API key, and exact DeepSeek model ID.
• Claude Code or Anthropic SDK: select a catalogue entry supporting Messages, such as an eligible Claude model, rather than a Chat-only DeepSeek entry.
• Codex CLI: select a Responses-compatible model from the same account instead of a Chat-only DeepSeek entry.
• LangChain or LlamaIndex: choose a compatible Chat Completions integration and verify every feature used by your application.

Evaluate variants systematically

A single permissive answer is not a meaningful benchmark. Compare standard, Flash, abliterated, and uncensored entries with the same legitimate inputs and settings.

1. Define benign tasks: include code explanation, refactoring, test generation, bilingual drafting, translation, and multi-step agent work relevant to your application.
2. Fix the configuration: record the model ID, prompt revision, generation settings, client, and date.
3. Repeat each test: run multiple trials rather than relying on one response.
4. Measure unnecessary refusals: count requests declined despite being answerable under your stated test policy.
5. Score task quality: check correctness, useful detail, uncertainty, code execution, and test results.
6. Inspect instruction behavior: verify formatting, system-message handling, project instructions, and tool integration.
7. Measure total cost: include input and output tokens, failed attempts, retries, output length, and end-to-end latency.

The repository does not claim live benchmark scores and does not independently inspect hosted model weights. Its benign evaluation prompts can help you design a test, but you must produce and document your own results.

Advanced tips

Test instruction precedence

Some uncensored entries may use a fixed persona. Check whether that persona supplements or replaces your system and developer instructions. Test required output formats, prohibited side effects, and tool permissions explicitly.

Version prompts and results

Store each prompt revision with the model ID, test date, settings, and output. If a prompt stops working after a model update, either revise it and document the failure or test a model-level variant instead of relying on the prompt layer.

Compare cost per successful result

Do not select a model using token rates alone. A cheaper model may cost more per completed task if it requires longer outputs, repeated corrections, or several retries. Compare standard and Flash entries using the same acceptance tests.

Start with small paid requests

Run a short request first, inspect its output and account charge, and only then scale to a larger benchmark. Use cached-input pricing only when the selected model supports it and the usage record confirms it.

Protect credentials and private data

Keep API keys in environment variables or a secret manager, apply appropriate permissions, and never commit keys to the repository. Hosted inference is not local inference, so review provider terms and retention policies before transmitting private or regulated information.

Keep human approval for consequential actions

Model labels do not establish safety or correctness. Review outputs and require approval before executing consequential code, modifying production systems, or acting on sensitive decisions.

Common limitations

• No-refusal terminology does not guarantee that a model will answer every request.
• Hosted behavior, catalogue availability, and pricing can change.
• A shared API key does not remove protocol differences between models.
• Prompt effectiveness may change when models or instruction hierarchies are updated.
• Uncensored output can still be inaccurate, incomplete, or unsuitable for deployment.
• Hosted model labels do not by themselves verify weight-level modifications.

Conclusion

This project provides two practical paths for experimentation: use the 35 bundled prompt files with compatible clients, or call a listed DeepSeek variant through RouterHub’s OpenAI-compatible Chat Completions endpoint. Start by confirming the live model ID and protocol, protect your key, run a small request, and compare variants with repeatable quality, refusal, latency, and cost measurements.