Gemini Native SDK-Anbindung

npm install @google/genai
# Erfordert >= 2.0.0; empfohlen: latest

pip install -U google-genai
# Erfordert >= 2.0.0

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({
  apiKey: "sk-***", // Ersetzen Sie dies durch Ihren bei AIHubMix generierten API Key
  httpOptions: {
    baseUrl: "https://aihubmix.com/gemini",
  },
});

from google import genai

client = genai.Client(
    api_key="sk-***",  # Ersetzen Sie dies durch Ihren bei AIHubMix generierten API Key
    http_options={"base_url": "https://aihubmix.com/gemini"},
)

const interaction = await ai.interactions.create({
  model: "gemini-3.5-flash",
  input: "Explain quantum computing in one sentence",
});

console.log(interaction.output_text);
console.log(interaction.usage);
// { total_tokens, total_input_tokens, total_output_tokens, ... }

interaction = client.interactions.create(
    model="gemini-3.5-flash",
    input="Explain quantum computing in one sentence",
)

print(interaction.output_text)

import fs from "node:fs";

const interaction = await ai.interactions.create({
  model: "gemini-3.1-flash-image",
  input: "A translucent banana-shaped glass lamp on a white desk, soft studio lighting.",
  response_modalities: ["text", "image"],
  response_format: { type: "image", aspect_ratio: "1:1", image_size: "1K" },
});

// Methode 1: output_image-Komfort-Eigenschaft (letztes generiertes Bild)
if (interaction.output_image?.data) {
  fs.writeFileSync("output.png", Buffer.from(interaction.output_image.data, "base64"));
}

// Methode 2: Steps durchlaufen, geeignet fuer mehrstufige gemischte Ausgaben
for (const step of interaction.steps ?? []) {
  for (const block of step.content ?? []) {
    if (block.type === "image" && block.data) {
      fs.writeFileSync("output.png", Buffer.from(block.data, "base64"));
    }
  }
}

import base64

interaction = client.interactions.create(
    model="gemini-3.1-flash-image",
    input="A translucent banana-shaped glass lamp on a white desk, soft studio lighting.",
    response_format={
        "type": "image",
        "aspect_ratio": "1:1",
        "image_size": "1K",
    },
)

# output_image-Komfort-Eigenschaft
if interaction.output_image:
    with open("output.png", "wb") as f:
        f.write(base64.b64decode(interaction.output_image.data))

const task = await ai.interactions.create({
  model: "gemini-3.5-flash",
  input: "Explain the water cycle in three sentences.",
  background: true,
});

console.log(task.id, task.status); // iact1_xxx in_progress

let result;
for (let i = 0; i < 60; i++) {
  await new Promise((r) => setTimeout(r, 3000));
  try {
    const current = await ai.interactions.get(task.id);
    if (["completed", "failed", "cancelled"].includes(current.status)) {
      result = current;
      break;
    }
  } catch (err) {
    continue; // Ergebnis noch nicht bereit, Polling fortsetzen
  }
}

console.log(result.output_text);
console.log(result.usage);

import time
from google.genai import errors

task = client.interactions.create(
    model="gemini-3.5-flash",
    input="Explain the water cycle in three sentences.",
    background=True,
)

print(task.id, task.status)  # iact1_xxx in_progress

result = None
for _ in range(60):
    time.sleep(3)
    try:
        current = client.interactions.get(task.id)
    except errors.APIError:
        continue  # Ergebnis noch nicht bereit, Polling fortsetzen
    if current.status in ("completed", "failed", "cancelled"):
        result = current
        break

print(result.output_text)
print(result.usage)

const response = await ai.models.embedContent({
  model: "gemini-embedding-2-preview",
  contents: "What is the meaning of life?",
  config: {
    outputDimensionality: 768, // Optional: Ausgabedimension angeben (128-3072), Standard 3072
  },
});

console.log("dimensions:", response.embeddings[0].values.length); // 768

from google.genai import types

result = client.models.embed_content(
    model="gemini-embedding-2-preview",
    contents="What is the meaning of life?",
    config=types.EmbedContentConfig(
        output_dimensionality=768,  # Optional: Ausgabedimension angeben (128-3072), Standard 3072
    ),
)

print(f"dimensions: {len(result.embeddings[0].values)}")  # 768

const longDocument = "Langer Text, der wiederholt referenziert wird...".repeat(500);

const cache = await ai.caches.create({
  model: "gemini-3.5-flash",
  config: {
    contents: longDocument,
    ttl: "300s",
  },
});

console.log("CachedContent name:", cache.name);
// Format: cachedContents/xxx

long_document = "Langer Text, der wiederholt referenziert wird..." * 500

cache = client.caches.create(
    model="gemini-3.5-flash",
    config={
        "contents": long_document,
        "ttl": "300s",
    },
)

print(f"CachedContent name: {cache.name}")

const response = await ai.models.generateContent({
  model: "gemini-3.5-flash",
  contents: "Please summarize the core points of the above document",
  config: { cachedContent: cache.name },
});

console.log(response.text);
console.log("cached tokens:", response.usageMetadata?.cachedContentTokenCount);

response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="Please summarize the core points of the above document",
    config={"cached_content": cache.name},
)

print(response.text)
print(f"cached tokens: {response.usage_metadata.cached_content_token_count}")

// CachedContent-Metadaten abfragen
const info = await ai.caches.get({ name: cache.name });
console.log("model:", info.model, "expireTime:", info.expireTime);

// Cache loeschen
await ai.caches.delete({ name: cache.name });

# CachedContent-Metadaten abfragen
info = client.caches.get(name=cache.name)
print(f"model: {info.model}  expire_time: {info.expire_time}")

# Cache loeschen
client.caches.delete(name=cache.name)