← Voltar aos guias

LLM APIs in Go, Rust and Java with 59API

Choose a Compatible API Path

Go, Rust, and Java teams do not need separate integrations for every model provider. An OpenAI-compatible API lets one client shape work with GPT models and Claude models while preserving your existing application architecture. 59API exposes that familiar interface at https://api.59api.com, with pay-as-you-go access to Claude Opus, Sonnet, Haiku, Fable, and GPT models. It is a practical choice when cost matters: the relay is priced competitively, uses native official-quality models rather than downgraded substitutes, and includes a referral rebate program.

Start by creating a 59API account, generating an API key, and storing it in your deployment secret manager as LLM_API_KEY. For local development, put the key in your shell environment rather than committing it to a repository. Set a second variable, LLM_BASE_URL=https://api.59api.com/v1. Confirm the exact model identifiers available in your 59API dashboard before hard-coding one; model catalogs and aliases can change.

Verify the Request Before Writing SDK Code

First prove credentials, networking, and billing with a minimal OpenAI-style chat-completions request. Send an Authorization header containing Bearer followed by your API key, a JSON body with a model name, and a messages array containing a user prompt. Keep the first prompt short, such as asking for a five-word summary. A successful response should contain one or more choices and assistant message content.

This small check prevents a common debugging mistake: attributing a missing key, wrong base URL, or unsupported model to an SDK. In production, never log the Authorization header or full prompts when they can contain customer data. Log a request ID, selected model, latency, status code, token usage when returned, and a redacted error category instead.

Implement It in Go

For Go, use an OpenAI-compatible client library or a standard net/http request. With an SDK, initialize the client with the API key and override its base URL to https://api.59api.com/v1. Create a chat-completion request with your configured model, a system instruction, and the user input. Read the first choice only after checking that choices is non-empty.

• Pass context.Context from the incoming HTTP request so cancellation reaches the model call.
• Set an HTTP client timeout; begin with 30 to 60 seconds for ordinary interactive requests.
• Return a stable application error to callers while logging the provider status and sanitized response body internally.
• For long answers, use streaming and forward deltas to the browser with server-sent events.

Keep client construction in one package. That makes the base URL, default model, retry policy, and telemetry consistent across handlers and makes a provider change a configuration task instead of a rewrite.

Implement It in Rust

In Rust, an OpenAI-compatible crate such as async-openai is a convenient option, though reqwest is equally suitable when you want complete control. Configure the client with the API key and API base, then build a typed chat request. Run it under Tokio, propagate errors with a typed error enum, and serialize only the fields your API needs to expose.

• Use a connect timeout and a total request timeout in the HTTP client.
• Guard concurrency with a semaphore when several user requests can trigger expensive generations at once.
• Retry only transient failures such as rate limits, connection failures, and selected 5xx responses.
• Use exponential backoff with jitter, and do not retry invalid requests or authentication failures.

Rust services benefit from separating request validation from prompt assembly. Validate user limits before calling the model, then create prompts from structured fields rather than allowing unbounded raw input to determine instructions.

Implement It in Java

Java services can use an OpenAI Java SDK configured with the 59API base URL, or Java 21 HttpClient for a dependency-light implementation. Create one reusable client during application startup; do not construct a new client for every request. Supply the bearer key from environment-backed configuration and make the chosen model configurable per environment.

When using Spring Boot, place the client behind a service interface and map timeout, upstream, and validation failures to clear HTTP responses. For streaming, use an asynchronous client path and ensure a disconnected browser cancels the upstream work. For batch jobs, use bounded executors so a queue spike cannot exhaust connection pools or spend unexpectedly.

Production Checklist

• Pin a default model in configuration and test a lower-cost fallback model for noncritical workloads.
• Set maximum input size, maximum output tokens, request deadlines, and per-user rate limits.
• Record cost-relevant usage metrics and alert on unexpected token or error-rate increases.
• Test malformed input, an empty choices response, 429 responses, 5xx responses, and slow streams.
• Keep prompts and model responses out of analytics unless they are explicitly redacted and retention-approved.

With a single OpenAI-compatible integration, Go, Rust, and Java services can use the model that fits each task without multiplying provider-specific code. Sign up for 59API when you are ready to test this flow with low-cost, pay-as-you-go access to Claude and GPT models.

Preços · Docs