Dolphin ai Production Checklist

1. Verify OpenAI-Compatible Endpoint Compatibility

Start by confirming the endpoint structure matches the standard OpenAI chat-completions format. Our API strictly adheres to this schema, so you can use existing SDKs without writing custom wrappers. The base URL is HTTPS://api.dolphinmodelos.com/v1, and you must set the model id to "uncensored" in every request. This ensures you are hitting the dedicated uncensored inference engine rather than a routed aggregator.

• Use the official OpenAI Python or Node.js SDKs.
• Override the base URL to point to our endpoint.
• Pass your API key in the Authorization header.

This approach eliminates the need for vendor-specific logic. You are connecting directly to an uncensored large language model. The response will follow the standard JSON structure. No hidden routing logic or proprietary fields will break your parser.

Verify the base URL before scaling. A single character change can break your integration.

This compatibility means you can swap in other models later if needed, but for now, you get pure, uncensored inference. The endpoint is designed for developers who want predictable, schema-compliant responses. It does not offer embeddings or image generation, so keep your payload focused on text.

Check the GET /v1/models endpoint to confirm the model id is listed as "uncensored". This is your primary anchor for all subsequent calls.

2. Implement Robust Streaming Error Handling

Stream errors are the most common point of failure in production LLM integrations. You must handle the Server-Sent Events (SSE) stream carefully. The final chunk contains the token usage data, but errors can also appear in earlier chunks.

• Listen for the "error" event type.
• Parse the final chunk for usage statistics.
• Handle network timeouts gracefully.

Do not assume the stream will always complete successfully. A 500 error might interrupt the stream mid-way. Your code should retry or alert the user accordingly.

Streaming via SSE allows for lower latency, but it requires robust error handling. If the connection drops, you lose the partial response. Store the last known state before reconnecting. This is crucial for uncensored models, which may generate longer or more varied outputs.

Never ignore the final chunk. It contains the billable token count.

Implement a timeout of 30 seconds for each chunk. If a chunk takes longer, assume the connection is dead. This prevents your application from hanging indefinitely. The API does not guarantee a specific latency, so build in resilience.

Use the official SDKs which handle most of this automatically. But if you are writing raw HTTP calls, parse the SSE format manually. Look for the "data:" prefix and parse the JSON.

3. Manage Context Window and Token Limits

The context window is limited to 100,000 tokens for both prompt and completion combined. This is a hard limit for the uncensored model. If your input exceeds this, the API will return an error.

• Calculate token counts before sending.
• Monitor the prompt length carefully.
• Set a max_tokens limit for output.

The maximum output per request is 16,000 tokens. If you do not set max_tokens, it defaults to 2,048 tokens. This is a safe default for most use cases.

However, for long-form content, you need to increase this limit. Be aware that longer outputs consume more credit. The price is $0.15 per 1M input tokens and $0.50 per 1M output tokens. This pricing is transparent and predictable.

Calculate your token usage before sending large prompts. A 50k token prompt leaves only 50k for output.

This balance is crucial for maintaining service quality. If you need more context, consider chunking your input. Do not rely on the API to truncate automatically. It will error out if you exceed the limit.

This limit applies to the total token count, not just the characters. Use a tokenizer library to get an accurate count. This ensures you stay within the budget and performance thresholds.

4. Configure Function Calling for Tool Use

Function calling allows your application to interact with external APIs via the LLM. The API supports tools and tool_choice parameters. This is essential for building agentic workflows.

• Define your function schemas in the request.
• Set tool_choice to "auto" or "required".
• Parse the function call arguments carefully.

The uncensored model is tuned to follow instructions precisely. This means it will rarely refuse a valid tool call. However, you must validate the output. The model may generate slightly malformed JSON.

Always validate the function arguments before executing them. This prevents errors in your downstream services. The API returns the function call in the standard OpenAI format. You can parse this using the official SDKs.

Test function calling with edge cases. The model may invent arguments if not constrained.

This is a feature of uncensored models. They are more flexible, but require more validation. Set the temperature to a lower value for consistent tool use. This reduces the likelihood of hallucinated arguments.

Use the JSON mode for even stricter output constraints. This ensures the model returns only valid JSON. It is a powerful combination for reliable automation.

5. Validate JSON Mode Constraints

JSON mode ensures the model returns a valid JSON object. This is critical for parsing the response in your code. Set the response_format parameter to {"type": "json_object"}.

• Enable JSON mode for structured data.
• Validate the output before parsing.
• Handle parsing errors gracefully.

The uncensored model respects this constraint well. It will not add markdown or extra text outside the JSON. This makes parsing reliable and fast.

However, JSON mode can sometimes reduce the model's creativity. It forces the model to stay within the schema. This is a trade-off you must consider. For strict data extraction, it is ideal. For creative writing, it may feel restrictive.

Always validate the JSON before using it. A single syntax error can break your app.

Use a JSON validator in your pipeline. This catches errors early. The API does not guarantee perfect JSON, but it is highly reliable.

Combine JSON mode with function calling for maximum precision. This ensures the model returns exactly what you expect. It is a powerful tool for building reliable AI applications.

6. Monitor Rate Limits and Concurrency

The API enforces strict rate limits to ensure fair usage. You are limited to 300 requests per minute per key. Additionally, you can have 8 concurrent requests at a time.

• Monitor your request count per minute.
• Limit concurrent requests to 8.
• Handle 429 Too Many Requests errors.

If you exceed these limits, the API will return a 429 error. You should implement exponential backoff in your retry logic.

This is crucial for production systems. A sudden spike in traffic can overwhelm your application if not managed. The 8 MB request body limit is also important. Large payloads can hit this limit quickly.

Implement a circuit breaker for rate limit errors. This prevents cascading failures.

This ensures your application remains stable. The API does not offer burst allowances, so plan your traffic accordingly.

Use a single API key per account. If you need more concurrency, you can generate a new key, but it replaces the old one. This is a simple but effective limit. Monitor your usage via the final chunk of the stream. This gives you real-time feedback on your token consumption.

7. Ensure Content Policy Alignment

The uncensored model does not refuse most adult or controversial topics. However, there is one hard limit: sexual content involving minors. This is always enforced.

• Check for minor-related content in your prompts.
• Expect no refusals for other adult topics.
• Validate output for your specific use case.

This makes the model ideal for creative writing and adult content. You do not need to worry about sudden refusals.

However, "uncensored" does not mean "unfiltered". The model may still generate low-quality or irrelevant content. You may need to post-process the output.

Define your own content boundaries. The API only enforces the minor limit.

This gives you flexibility but also responsibility. Validate the output for your audience. Use a simple keyword filter if needed.

The model is tuned for lawful adult use. It does not guarantee suitability for children. Be clear about your target audience. This ensures you avoid unexpected complaints. The API is designed for developers who know what they want.

8. Optimize Prompt Structure for Length

Prompt structure affects both performance and cost. Long prompts consume more tokens and increase latency. Break your prompts into smaller chunks if possible.

• Keep system prompts concise.
• Use few-shot examples sparingly.
• Remove unnecessary whitespace.

The uncensored model handles long prompts well, but you are limited by the 100k token window. Plan your token budget carefully.

Use the temperature parameter to control creativity. A lower temperature produces more deterministic outputs. This is useful for function calling and JSON mode.

Test different prompt structures. Small changes can significantly improve output quality.

This is a key part of prompt engineering. The model is flexible, but it needs clear instructions. Provide context and examples to guide the model.

Monitor the token usage in each request. This helps you identify inefficient prompts. Optimize for both speed and cost. The API pricing is transparent, so you can calculate the exact cost of each prompt. This allows you to scale efficiently.

9. Test with Representative Uncensored Prompts

Testing is the final step before deployment. Use prompts that reflect your actual use cases. Test for both standard and edge cases.

• Send a variety of prompt types.
• Check for consistency in responses.
• Validate error handling.

The uncensored model should handle a wide range of topics. Test with controversial or adult themes to ensure no refusals.

Also test with function calls and JSON mode. Ensure the output is parseable and correct. This comprehensive testing ensures a smooth launch.

Test with your actual data. Synthetic data may not reveal all issues.

This is the best way to catch bugs early. The API is reliable, but your code may have issues. Verify the integration end-to-end.

Use the trial credit to test thoroughly. It gives you $0.50 of credit for 7 days. This is enough to test most scenarios. Sign up with Google or email to get started. This makes it easy to validate your integration before committing.