Troubleshooting uncensored ai chat: common mistakes

Why your uncensored LLM is still refusing requests

The most common reason an uncensored LLM appears to refuse a request is not a content filter, but a client-side error. Our model is tuned to answer without content refusals for lawful adult use, but it still respects the hard content limit: sexual content involving minors is always refused. If you see a refusal, check the response body for an error code or a specific refusal message rather than assuming the model is broken.

Another frequent issue is the base_url configuration. If you are migrating from another provider, ensure you are pointing to https://api.unrestrictedgptchat.com/v1. A mismatched base_url will result in a 404 or 401 error, which looks like a refusal but is actually a connectivity issue. Also, verify that your API key is active and not expired. We issue one active key per account, and generating a new key replaces the old one immediately.

Common refusal scenarios

• Hard limit violation (minor content).
• Invalid base_url or API key.
• Malformed request body.

Understanding the 100k context window limit

Your uncensored AI chat session can handle a total of 100,000 tokens for both the prompt and the completion combined. This large context window allows you to feed in extensive documentation or long conversation histories without losing track of the narrative. However, you must manage this window carefully to avoid hitting the limit mid-conversation.

When the context window is nearly full, the model may start forgetting earlier parts of the conversation. To mitigate this, consider truncating older messages or summarizing them before adding new ones. The model id you use is simply "uncensored," and it runs on our own servers, not as a proxy to another vendor. This ensures consistent behavior regardless of the input length, as long as you stay within the 100k token boundary.

Managing context efficiently

• Track token usage per message.
• Summarize older messages to save space.
• Monitor the total token count in your client.

Max output tokens: avoiding truncated responses

By default, the model will generate up to 2,048 tokens per request if you do not specify a max_tokens value. If your response is cut off mid-sentence, you likely need to increase this limit. You can set max_tokens up to 16,000 tokens per request, which is sufficient for most long-form content generation needs.

Keep in mind that increasing max_tokens also increases your token usage and cost. Since billing is based on actual tokens used, longer responses will cost more. However, errors and refusals are free, so you only pay for successful completions. This prepaid model means you can experiment with higher max_tokens without worrying about unexpected charges from a subscription service.

Setting max_tokens

• Default: 2,048 tokens.
• Maximum: 16,000 tokens.
• Cost: $0.50 per 1M output tokens.

Streaming vs. non-streaming: handling SSE correctly

Streaming via Server-Sent Events (SSE) is essential for a smooth user experience, especially in chat interfaces. The API returns tokens one by one, allowing you to display text as it is generated. However, you must handle the SSE stream correctly to avoid missing tokens or misinterpreting the data.

Each SSE event contains a chunk of text, and the final chunk includes the token usage data. Make sure your client-side parser can aggregate these chunks and extract the usage statistics from the last event. If you are using a standard OpenAI SDK, streaming is usually handled automatically, but custom implementations require careful attention to the SSE protocol.

Streaming best practices

• Parse SSE events correctly.
• Aggregate tokens for display.
• Extract usage from the final chunk.

Function calling: ensuring tool compatibility

Our API supports function calling, allowing the model to generate structured data that can be used to trigger external tools. This is useful for tasks like scheduling, data retrieval, or executing specific actions. The model will return a JSON object containing the function name and arguments, which your client code can then parse and execute.

Ensure that your function definitions are accurate and match the expected input format. The model may hallucinate arguments if the function definition is ambiguous. Test your function calling setup thoroughly to ensure that the model can reliably generate the correct function calls. Remember that the model id is "uncensored," and it is optimized for generating accurate and useful function calls without unnecessary refusals.

Function calling tips

• Define functions clearly.
• Test argument generation.
• Handle hallucinated arguments.

JSON mode: enforcing strict output formats

When you need the model to return strictly formatted JSON, you can use the response_format parameter set to json_object. This mode enforces that the output is valid JSON, which is crucial for integrating the model with other systems. However, the model may still struggle with complex JSON structures if the prompt is not clear.

Use JSON mode when you need reliable data extraction or when you are building a system that depends on specific JSON schemas. This feature is particularly useful for developers who want to avoid parsing errors and ensure that the output is always valid. The model supports this mode alongside other parameters like temperature and top_p, allowing you to fine-tune the output quality.

JSON mode settings

• Set response_format to json_object.
• Ensure clear prompts for structure.
• Validate output for compliance.

Rate limits: managing concurrent requests

The API allows 300 requests per minute per key and up to 8 concurrent requests at the same time. If you exceed these limits, you will receive a 429 Too Many Requests error. This is important to consider if you are building a high-traffic application or running multiple instances of your client.

To manage rate limits effectively, implement exponential backoff in your client code. This will help you handle temporary spikes in traffic without overwhelming the API. You can also monitor your request rate and adjust your concurrency settings accordingly. Remember that each key is limited to these rates, so if you need higher throughput, you may need to distribute requests across multiple keys.

Rate limit strategies

• Implement exponential backoff.
• Monitor request rate.
• Distribute requests across keys.

Billing surprises: prepaid credit vs. subscriptions

Our billing model is prepaid, meaning you top up your account with crypto and pay only for the tokens you use. This is different from a subscription model where you pay a fixed monthly fee regardless of usage. With prepaid credit, you have full control over your spending, and errors are free, so you only pay for successful completions.

When you top up, you can add any whole amount from $20 to $500 in USDT (TRC20) or USDC (Base). You also get bonus credit depending on the amount: +5% from $50, +10% from $100, and +15% from $200. This bonus credit never expires, so you can use it whenever you need it. This transparent billing model helps you avoid unexpected charges and makes it easy to budget your API usage.

Billing details

• Prepaid credit, no subscription.
• Crypto only: USDT or USDC.
• Bonus credit for larger top-ups.

Privacy: are your prompts used for training?

One of the key concerns for many developers is whether their prompts are used for training. With our API, your prompts are not used for training, ensuring that your data remains private. This is particularly important for businesses that handle sensitive information or want to keep their conversation data secure.

You can sign up with just an email address, and no phone number is required. This minimal data collection further enhances your privacy. Additionally, since we are an independent service, we do not share your data with other vendors or use it to improve other models. Your prompts are used solely to generate responses for your requests.

Privacy features

• Prompts not used for training.
• Minimal data collection.
• Independent service.