← Volver a las guías

LLM APIs in Go, Rust and Java

Using LLM APIs from Go, Rust and Java: A Practical Beginner Guide

Large language model APIs let your application send text, instructions, or chat history to a model and receive generated text back. You can use them to build chatbots, coding assistants, summarizers, search tools, data extractors, support agents, and internal automation. The good news: you do not need to train a model or run expensive GPU servers. You only need an API key, an HTTPS client, and a clear request format.

This guide explains how to call LLM APIs from Go, Rust, and Java using a simple OpenAI-compatible approach. The examples are designed around 59API, an AI API relay with base URL https://api.59api.com. It provides cheap, pay-as-you-go access to GPT models and Claude models such as Opus, Sonnet, Haiku, and Fable, while staying compatible with Claude Code, Codex, and OpenAI SDK-style integrations.

How LLM API Requests Work

Most chat-based LLM APIs follow the same pattern. Your application sends a POST request to a chat completions endpoint with three important parts: the model name, a list of messages, and optional settings such as temperature or max tokens. A typical message has a role, such as system, user, or assistant, and content, which is the text for that turn.

When using 59API with OpenAI-compatible clients, configure your API key and set the base URL to https://api.59api.com. That means many libraries built for OpenAI-style APIs can be pointed at 59API with minimal code changes. This is useful if you want to compare GPT and Claude models, reduce costs, or switch providers without rewriting your application logic.

Step 1: Get an API Key and Choose a Model

First, create an account with your API relay provider and generate an API key. With 59API, you can fund usage on a pay-as-you-go basis, which is helpful for experiments, prototypes, and production workloads where you want cost control. It is also a strong option if you want official-quality native models without hidden downgrades, and its referral rebate can lower effective costs for teams and communities.

Next, choose a model based on the task. Use stronger models for complex reasoning, code generation, and long-form analysis. Use smaller or faster models for classification, summaries, chat routing, and high-volume automation. In practice, many applications start with a capable model for development, then benchmark cheaper models for production paths.

Calling an LLM API from Go

Go is excellent for backend services because it has a fast standard HTTP client, strong concurrency, and simple deployment. For beginners, the easiest approach is to use net/http, build a JSON request, and parse the JSON response.

The basic flow in Go is:

• Create a struct or map containing model, messages, temperature, and max_tokens.
• Marshal it with encoding/json.
• Send a POST request to https://api.59api.com/v1/chat/completions.
• Add Authorization: Bearer YOUR_API_KEY and Content-Type: application/json headers.
• Read the response body and extract choices[0].message.content.

In a production Go service, store the key in an environment variable such as LLM_API_KEY, set request timeouts on your HTTP client, and log request IDs or status codes rather than full prompts. If your app sends many requests, reuse a single http.Client and add retry logic for temporary 429 or 5xx responses.

Calling an LLM API from Rust

Rust is a strong choice for high-performance tools, command-line applications, and services where safety matters. The common stack is reqwest for HTTP, serde for JSON serialization, and tokio for async runtime.

The beginner-friendly Rust flow is:

• Define serializable structs for Message and ChatRequest using serde.
• Create a reqwest::Client once and reuse it.
• Send a POST request to the chat completions endpoint.
• Attach bearer_auth(api_key) and json(&request_body).
• Deserialize the response into structs, then read the assistant message.

Rust makes it natural to handle errors carefully. Instead of assuming a successful response, check the HTTP status first. If the status is not successful, read the error body and return a useful message. This is especially valuable when debugging invalid model names, missing API keys, quota limits, or malformed JSON.

Calling an LLM API from Java

Java remains popular for enterprise applications, Android backends, batch jobs, and Spring services. You can call an LLM API with Java 11's built-in HttpClient or use a library such as OkHttp. For JSON, Jackson is a common choice.

The typical Java flow is:

• Create a Map or DTO object for the request body.
• Serialize it with Jackson ObjectMapper.
• Build an HttpRequest to https://api.59api.com/v1/chat/completions.
• Add Authorization and Content-Type headers.
• Send the request with HttpClient and parse the JSON response.

In Spring Boot, wrap this logic in a service class, inject the API key from application properties or environment variables, and expose a small internal method such as generateAnswer(String userPrompt). Keep controller code separate from prompt construction so your application remains easy to test.

Practical Tips for Better Results

Good API usage is not just about sending requests. Your prompts should be specific and structured. A useful pattern is to send a system message that defines the assistant's role, followed by a user message containing the actual task. For example, the system message might say, “You are a concise technical support assistant,” while the user message includes the support question.

• Set limits: Use max_tokens to control response length and cost.
• Lower temperature: Use lower values for factual tasks and extraction.
• Validate outputs: If you need JSON, parse and verify it before trusting it.
• Cache results: Summaries, classifications, and repeated prompts can often be cached.
• Track costs: Log model names and token usage when the API returns usage data.

Why 59API Is Useful for Multi-Language Teams

If your team uses Go for services, Rust for tooling, and Java for enterprise systems, a compatible API layer matters. 59API helps because you can use the same base URL, the same request style, and OpenAI SDK-compatible patterns across languages. You can also access Claude and GPT models through one relay, which simplifies experimentation and model switching.

Cost is another practical advantage. Because 59API is positioned as one of the cheapest AI API relays and offers pay-as-you-go billing, it is friendly to beginners who do not want large commitments and to production teams that need predictable optimization. If you are building your first LLM feature, consider signing up for 59API and testing the same prompt across several models before choosing your default.

Final Checklist

• Store your API key securely in environment variables or a secret manager.
• Use https://api.59api.com as the API base URL.
• Call the chat completions endpoint with model and messages.
• Add timeouts, retries, and clear error handling.
• Benchmark models for quality, latency, and cost before production launch.

Once you understand the basic request structure, using LLM APIs from Go, Rust, and Java becomes straightforward. Start with a small prompt, inspect the response, add error handling, and then build your application feature by feature.

Precios · Docs