Cómo usar la API de Gemini 3.5 Flash: Model ID, precios y ejemplos de código

pip install openai

npm install openai

from openai import OpenAI

client = OpenAI(
    api_key="your-evolink-api-key",
    base_url="https://api.evolink.ai/v1"
)

response = client.chat.completions.create(
    model="gemini-3.5-flash",
    messages=[
        {"role": "user", "content": "What is Gemini 3.5 Flash best at?"}
    ]
)

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

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "your-evolink-api-key",
  baseURL: "https://api.evolink.ai/v1",
});

const response = await client.chat.completions.create({
  model: "gemini-3.5-flash",
  messages: [
    { role: "user", content: "What is Gemini 3.5 Flash best at?" },
  ],
});

console.log(response.choices[0].message.content);

response = client.chat.completions.create(
    model="gemini-3.5-flash",
    messages=[
        {"role": "system", "content": "You are a senior software engineer. Be concise and precise."},
        {"role": "user", "content": "Explain the difference between a mutex and a semaphore in 3 sentences."}
    ],
    temperature=0.3,
    max_tokens=512
)

import base64

with open("screenshot.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="gemini-3.5-flash",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What error is shown in this screenshot? Suggest a fix."},
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_data}"}}
            ]
        }
    ]
)

stream = client.chat.completions.create(
    model="gemini-3.5-flash",
    messages=[{"role": "user", "content": "Write a Python function that validates email addresses."}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

const stream = await client.chat.completions.create({
  model: "gemini-3.5-flash",
  messages: [{ role: "user", content: "Write a Python function that validates email addresses." }],
  stream: true,
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content;
  if (content) process.stdout.write(content);
}

messages = [
    {"role": "system", "content": "You are a helpful coding assistant."},
    {"role": "user", "content": "Write a linked list implementation in Python."},
]

# First turn
response = client.chat.completions.create(model="gemini-3.5-flash", messages=messages)
assistant_message = response.choices[0].message.content
messages.append({"role": "assistant", "content": assistant_message})

# Follow-up
messages.append({"role": "user", "content": "Now add a reverse() method."})
response = client.chat.completions.create(model="gemini-3.5-flash", messages=messages)
print(response.choices[0].message.content)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_database",
            "description": "Search the internal knowledge base",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"},
                    "limit": {"type": "integer", "description": "Max results to return"}
                },
                "required": ["query"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gemini-3.5-flash",
    messages=[{"role": "user", "content": "What's the weather in Tokyo and find articles about climate change?"}],
    tools=tools,
    tool_choice="auto"
)

# The model may call one or both tools
for tool_call in response.choices[0].message.tool_calls:
    print(f"Function: {tool_call.function.name}")
    print(f"Arguments: {tool_call.function.arguments}")

const tools = [
  {
    type: "function",
    function: {
      name: "run_tests",
      description: "Run the test suite and return results",
      parameters: {
        type: "object",
        properties: {
          test_file: { type: "string", description: "Path to test file" },
          verbose: { type: "boolean", description: "Show detailed output" },
        },
        required: ["test_file"],
      },
    },
  },
];

const response = await client.chat.completions.create({
  model: "gemini-3.5-flash",
  messages: [{ role: "user", content: "Run the tests for auth module" }],
  tools,
  tool_choice: "auto",
});

const toolCalls = response.choices[0].message.tool_calls;
for (const call of toolCalls) {
  console.log(`Call: ${call.function.name}(${call.function.arguments})`);
}

response = client.chat.completions.create(
    model="gemini-3.5-flash",
    messages=[
        {"role": "system", "content": "Extract structured data from the text. Return valid JSON only."},
        {"role": "user", "content": "John Smith, age 34, works at Acme Corp as a senior engineer since 2022. Email: [email protected]"}
    ],
    response_format={"type": "json_object"}
)

import json
data = json.loads(response.choices[0].message.content)
print(data)
# {"name": "John Smith", "age": 34, "company": "Acme Corp", "role": "senior engineer", "start_year": 2022, "email": "[email protected]"}

from openai import OpenAI
import subprocess
import json

client = OpenAI(api_key="your-evolink-api-key", base_url="https://api.evolink.ai/v1")

def run_tests(test_file: str) -> dict:
    """Run tests and return results."""
    result = subprocess.run(["python", "-m", "pytest", test_file, "-v", "--tb=short"],
                          capture_output=True, text=True, timeout=60)
    return {"passed": result.returncode == 0, "output": result.stdout + result.stderr}

def read_file(path: str) -> str:
    with open(path) as f:
        return f.read()

def write_file(path: str, content: str):
    with open(path, "w") as f:
        f.write(content)

# Initial context
module_code = read_file("src/auth.py")
test_code = read_file("tests/test_auth.py")
test_result = run_tests("tests/test_auth.py")

messages = [
    {"role": "system", "content": """You are a coding agent. Your job is to fix failing tests.
Rules:
1. Read the code and test output carefully.
2. Identify the root cause.
3. Output the complete fixed file content.
4. Do not change test expectations — fix the implementation."""},
    {"role": "user", "content": f"""Module code:\n```python\n{module_code}\n```\n\nTest code:\n```python\n{test_code}\n```\n\nTest output:\n```\n{test_result['output']}\n```"""}
]

MAX_ITERATIONS = 15
for i in range(MAX_ITERATIONS):
    response = client.chat.completions.create(
        model="gemini-3.5-flash",
        messages=messages,
        temperature=0.2,
        max_tokens=8192
    )

    reply = response.choices[0].message.content
    messages.append({"role": "assistant", "content": reply})

    # Extract and apply the fix
    if "```python" in reply:
        code_block = reply.split("```python")[1].split("```")[0]
        write_file("src/auth.py", code_block)

    # Re-run tests
    test_result = run_tests("tests/test_auth.py")

    if test_result["passed"]:
        print(f"All tests pass after {i + 1} iterations.")
        break

    messages.append({"role": "user", "content": f"Tests still failing:\n```\n{test_result['output']}\n```\nAnalyze the failure and try again."})
else:
    print(f"Failed to fix after {MAX_ITERATIONS} iterations.")

def coding_sub_agent(task: str, context: str) -> str:
    """Fast coding sub-agent using Gemini 3.5 Flash."""
    response = client.chat.completions.create(
        model="gemini-3.5-flash",
        messages=[
            {"role": "system", "content": "You are a fast coding sub-agent. Complete the task concisely."},
            {"role": "user", "content": f"Context:\n{context}\n\nTask:\n{task}"}
        ],
        temperature=0.2,
        max_tokens=4096
    )
    return response.choices[0].message.content

def reasoning_agent(task: str) -> str:
    """Deep reasoning agent using Gemini 3.1 Pro for complex decisions."""
    response = client.chat.completions.create(
        model="gemini-3.1-pro-preview",
        messages=[
            {"role": "system", "content": "You are a senior architect. Analyze deeply and decide."},
            {"role": "user", "content": task}
        ],
        temperature=0.3,
        max_tokens=4096
    )
    return response.choices[0].message.content

# Coordinator pattern: Pro decides, Flash executes
plan = reasoning_agent("Design a refactoring plan for the auth module to support OAuth2.")
subtasks = parse_subtasks(plan)

results = []
for subtask in subtasks:
    result = coding_sub_agent(subtask, context=module_code)
    results.append(result)

response = client.chat.completions.create(
    model="gemini-3.5-flash",
    messages=messages,
    max_tokens=4096  # Reasonable limit for code output
)

def route_request(task_type: str) -> str:
    routing_table = {
        "architecture": "gemini-3.1-pro-preview",      # Deep reasoning
        "coding": "gemini-3.5-flash",           # Fast iteration
        "classification": "gemini-3.1-flash-lite",  # Cheapest
        "review": "gemini-3.5-flash",           # Good balance
        "chat": "gemini-3.5-flash",             # Production default
    }
    return routing_table.get(task_type, "gemini-3.5-flash")