How to Use Gemini 3.8 Flash on EvoLink: Production Guide

Quick Start

curl https://direct.evolink.ai/v1/chat/completions \
  -H "Authorization: Bearer $EVOLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash",
    "messages": [
      {"role": "user", "content": "Return three rollout risks for an AI API migration."}
    ],
    "max_tokens": 500
  }'

What You Need

• An EvoLink account and API key stored in an environment variable, never committed to source control.
• A client capable of HTTPS JSON requests, or an OpenAI-compatible SDK with a custom base_url.
• A small representative evaluation set and measurable acceptance rules.
• Logging for model ID, status, latency, token usage, retries, and application-level acceptance.
• A fallback model such as Gemini 3.7 Flash during rollout.

Gemini 3.8 Flash accepts text, image, video, audio, and PDF input and returns text. Google documents a 1,048,576-token input context and up to 65,536 output tokens. Treat those limits as capacity, not a reason to fill every request.

Choose the API Surface

EvoLink exposes two useful request styles for Gemini workloads:

OpenAI-Compatible Python Example

Install the OpenAI Python package, then point it at EvoLink:

pip install openai

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["EVOLINK_API_KEY"],
    base_url="https://direct.evolink.ai/v1",
)

response = client.chat.completions.create(
    model="gemini-3.8-flash",
    messages=[
        {
            "role": "system",
            "content": "Answer with concise, testable recommendations.",
        },
        {
            "role": "user",
            "content": "Review this deployment plan and identify missing rollback gates.",
        },
    ],
    max_tokens=800,
)

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

Keep the first request simple. Confirm authentication, route access, response parsing, and usage fields before adding tools, long context, or streaming.

Gemini-Native Request Example

curl "https://direct.evolink.ai/v1beta/models/gemini-3.8-flash:generateContent" \
  -H "Authorization: Bearer $EVOLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{"text": "Create a five-step canary checklist for this API release."}]
    }],
    "generationConfig": {
      "maxOutputTokens": 800,
      "thinkingConfig": {"thinkingLevel": "medium"}
    }
  }'

Thinking Levels and Migration Rules

When migrating an older Gemini client, audit these items:

A request returning HTTP 200 is not enough. Revalidate structured output, tool arguments, multi-turn state, and refusal behavior after the migration.

Multimodal Input Without Context Waste

The model can understand text, images, video, audio, and PDFs, but a 1M-token window does not make every large payload useful. Build context deliberately:

• Include the document sections or media segments needed for the decision.
• Keep stable system instructions, repository guidance, and tool schemas in a consistent prefix so caching has a chance to help.
• Retrieve relevant evidence before attaching an entire archive.
• Set an output budget appropriate for the task; the 65,536-token maximum is a ceiling.
• Record input and cache-read tokens separately so “large context” does not hide avoidable spend.

For repeated long documents, compare cache-hit behavior on a stable prompt prefix. Google’s introductory cache-read rate is $0.075 per million tokens through December 31, 2026, but EvoLink billing should be verified in your live account.

Production Rollout in Five Stages

1. Verify access and pricing

Create a restricted test key, confirm the model appears in the account’s available routes, send a small request, and check the resulting usage or billing record. A public model page confirms intended availability, not your account-specific call path.

2. Validate the request contract

Test synchronous requests first. Then test streaming, structured output, tools, long context, and multimodal input as separate cases. This isolates protocol failures from model-quality failures.

3. Replay a fixed evaluation set

Compare 3.8 Flash with the current baseline at the same thinking level. Measure first-pass success, accepted deliverables, output and thinking tokens, cache hits, valid tool calls, latency, human correction, and fallback rate.

4. Canary observable traffic

Start with a small percentage or a low-risk workload class. Attach the chosen model ID and evaluation cohort to every trace. Avoid auto-promoting based only on aggregate HTTP success.

5. Promote or roll back by written gates

Promote only if the model clears predefined quality, cost, and latency thresholds. Roll back by restoring the prior model value when critical errors, accepted-task cost, or latency crosses its limit.

Error Handling That Belongs in Production

Use bounded retries only for transient failures such as rate limits, upstream unavailability, or transport timeouts. Do not retry malformed payloads or unsupported parameters unchanged.

Recommended behavior:

• Retry transient failures with exponential backoff and jitter.
• Set a maximum attempt count and an end-to-end deadline.
• Reuse an idempotency strategy where the application can create side effects.
• Log request IDs and sanitized error bodies; never log API keys or sensitive prompts.
• Route to a tested fallback when the deadline or error threshold is reached.
• Treat repeated 400-class errors as a contract problem to fix, not capacity to outwait.

Observability Checklist

For every request, capture:

• application feature and evaluation cohort;
• requested and served model IDs;
• protocol and endpoint family;
• thinking level and output limit;
• input, output, thinking, and cache-read tokens when returned;
• latency, status, error class, and retry count;
• tool-call validity or schema-validation result;
• application acceptance, reviewer correction, and fallback outcome.

This data lets a unified API gateway support model selection instead of becoming an opaque proxy. You can keep multiple Gemini routes behind one client while still knowing which route creates value.

Common Setup Mistakes

• Sending gemini-3-8-flash instead of gemini-3.8-flash as the model ID.
• Using Gemini-native contents on the OpenAI-compatible endpoint.
• Relying on minimal being silently downgraded to low, combining thinkingBudget with thinkingLevel, relying on ignored sampling controls, or ending the conversation with role model.
• Filling the context window without retrieval or relevance filtering.
• Assuming Google’s public rate is identical to the live EvoLink account rate.
• Declaring success after one HTTP 200 without checking response shape and billing.
• Switching the production default without a measured fallback path.

FAQ

What is the Gemini 3.8 Flash model ID?

Which EvoLink endpoint should I use?

Can I use the OpenAI Python SDK?

What thinking level should I start with?

Does Gemini 3.8 Flash support images, video, audio, and PDFs?

Yes, as input modalities. It returns text and does not provide image, audio, or live-stream generation.

Is 3.8 Flash cheaper than 3.7 Flash?

Not by rate card during the Google introductory period: their input, output, and cache-read rates match. Google says 3.8 uses more tokens, so compare the complete cost per accepted task.

How do I confirm that my integration is production-ready?

Verify a successful call and its billing record, test each protocol feature you use, replay a fixed evaluation set, canary real traffic, and retain an explicit rollback.

Where can I compare all Gemini routes?

Sources and Verification Notes

• Google: Gemini 3.8 Flash launch
• Google AI for Developers: Gemini 3.8 Flash model
• Google AI for Developers: Gemini API pricing
• Google Cloud: Gemini 3.8 Flash guidance
• EvoLink: Gemini native API quickstart
• EvoLink: Gemini native API reference
• EvoLink: Gemini OpenAI-compatible quickstart