Gemini 가이드

Gemini 모델 전달

Gemini 시리즈의 경우 두 가지 호출 방법, 즉 네이티브 API 호출과 OpenAI 호환 호출을 제공합니다.
시작하기 전에 pip install google-genai 또는 pip install -U google-genai를 실행하여 네이티브 종속성을 설치하거나 업데이트해야 합니다. 1️⃣ 네이티브 전달의 경우 주로 내부 클라이언트 설정에 AiHubMix API 키와 요청 URL을 주입해야 합니다.
⚡️ 참고: URL 형식은 기존의 base_url 사용법과 다릅니다. 아래 예를 참조하십시오:

client = genai.Client(
    api_key="sk-***",  # AiHubMix에서 생성한 키로 교체
    http_options={"base_url": "https://aihubmix.com"},
)

2️⃣ OpenAI 호환 형식의 경우 범용 v1 엔드포인트를 유지합니다.

client = OpenAI(
    api_key="sk-***", # AiHubMix에서 생성한 키로 교체
    base_url="https://aihubmix.com/v1",
)

3️⃣ 2.5 시리즈의 경우 추론 과정을 표시해야 하는 경우 두 가지 방법이 있습니다:

네이티브 호출: include_thoughts=True 전달
OpenAI 호환 방법: reasoning_effort 전달

자세한 사용법은 아래 코드 예제를 참조할 수 있습니다.

Gemini 2.5 추론 모델 정보

전체 2.5 시리즈는 추론 모델로 구성됩니다.
2.5 Flash는 Claude Sonnet 3.7과 유사한 하이브리드 모델입니다. 최적의 제어를 위해 thinking_budget 매개변수를 조정하여 추론 동작을 미세 조정할 수 있습니다.
2.5 Pro는 순수 추론 모델입니다. 사고를 비활성화할 수 없으며 thinking_budget을 명시적으로 설정해서는 안 됩니다.

Python 사용 예제:

from google import genai
from google.genai import types

def generate():
    client = genai.Client(
        api_key="sk-***", # 🔑 AiHubMix 키로 교체
        http_options={"base_url": "https://aihubmix.com/gemini"},
    )

    model = "gemini-2.0-flash"
    contents = [
        types.Content(
            role="user",
            parts=[
                types.Part.from_text(text="""How do I know I'm not just wasting my time?"""),
            ],
        ),
    ]

    print(client.models.generate_content(
        model=model,
        contents=contents,
    ))

if __name__ == "__main__":
    generate()

from google import genai
from google.genai import types

def generate():
    client = genai.Client(
        api_key="sk-***", # 🔑 AiHubMix 키로 교체
        http_options={"base_url": "https://aihubmix.com/gemini"},
    )

    model = "gemini-2.0-flash"
    contents = [
        types.Content(
            role="user",
            parts=[
                types.Part.from_text(text="""How do I know I'm not just wasting my time?"""),
            ],
        ),
    ]
    generate_content_config = types.GenerateContentConfig(
        response_mime_type="text/plain",
    )

    for chunk in client.models.generate_content_stream(
        model=model,
        contents=contents,
        config=generate_content_config,
    ):
        print(chunk.text, end="")

if __name__ == "__main__":
    generate()

from google import genai
from google.genai import types

def generate():
    client = genai.Client(
        api_key="sk-***", # 🔑 AiHubMix 키로 교체
        http_options={"base_url": "https://aihubmix.com/gemini"},
    )

    model = "gemini-2.5-flash-preview-04-17" #gemini-2.5-pro-preview-03-25、gemini-2.5-flash-preview-04-17
    contents = [
        types.Content(
            role="user",
            parts=[
                types.Part.from_text(text="""How do I know I'm not just wasting my time?"""),
            ],
        ),
    ]
    generate_content_config = types.GenerateContentConfig(
        thinking_config = types.ThinkingConfig(
            thinking_budget=2048, #범위: 0-16K. 기본값 1024, 최상의 성능을 위해 16000
        ),
        response_mime_type="text/plain",
    )

    for chunk in client.models.generate_content_stream(
        model=model,
        contents=contents,
        config=generate_content_config,
    ):
        print(chunk.text, end="")

if __name__ == "__main__":
    generate()

from google import genai
from google.genai import types

def generate():
    client = genai.Client(
        api_key="sk-***", # 🔑 AiHubMix 키로 교체
        http_options={"base_url": "https://aihubmix.com/gemini"},
    )

    model = "gemini-2.5-pro-preview-03-25"
    contents = [
        types.Content(
            role="user",
            parts=[
                types.Part.from_text(text="""How do I know I'm not just wasting my time?"""),
            ],
        ),
    ]
    generate_content_config = types.GenerateContentConfig(
        response_mime_type="text/plain",
    )

    for chunk in client.models.generate_content_stream(
        model=model,
        contents=contents,
        config=generate_content_config,
    ):
        print(chunk.text, end="")

if __name__ == "__main__":
    generate()

from google import genai
from google.genai import types

def generate():
    client = genai.Client(
        api_key="sk-***", # 🔑 AiHubMix 키로 교체
        http_options={"base_url": "https://aihubmix.com/gemini"},
    )

    model = "gemini-2.5-pro-preview-05-06"
    contents = [
        types.Content(
            role="user",
            parts=[
                types.Part.from_text(text="""How is the Rule of 72 in finance derived?"""),
            ],
        ),
    ]
    generate_content_config = types.GenerateContentConfig(
        response_mime_type="text/plain",
        thinking_config=types.ThinkingConfig(
            include_thoughts=True  # 사고 내용 표시
        ),
    )

    final_usage_metadata = None
    
    for chunk in client.models.generate_content_stream(
        model=model,
        contents=contents,
        config=generate_content_config,
    ):
        if chunk.candidates and len(chunk.candidates) > 0:
            for part in chunk.candidates[0].content.parts:
                if part.text:
                    if part.thought:
                        print(part.text, end="")
                    else:
                        print(part.text, end="")

        if chunk.usage_metadata:
            final_usage_metadata = chunk.usage_metadata
    
    if final_usage_metadata:
        print(f"\n\n📊 토큰 사용량:")
        print(f"사고 토큰: {getattr(final_usage_metadata, 'thoughts_token_count', '사용 불가')}")
        print(f"출력 토큰: {getattr(final_usage_metadata, 'candidates_token_count', '사용 불가')}")
        print(f"총계: {final_usage_metadata}")

if __name__ == "__main__":
    generate()

Gemini 2.5 Flash: 빠른 작업 지원

OpenAI 호환 호출 예제:

from openai import OpenAI

client = OpenAI(
    api_key="AIHUBMIX_API_KEY", # AiHubMix에서 생성한 키로 교체
    base_url="https://aihubmix.com/v1",
)

completion = client.chat.completions.create(
    model="gemini-2.5-flash-preview-04-17-nothink",
    messages=[
        {
            "role": "user",
            "content": "Explain the Occam's Razor concept and provide everyday examples of it"
        }
    ]
)

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

from openai import OpenAI

client = OpenAI(
    api_key="sk-***", # AiHubMix에서 생성한 키로 교체
    base_url="https://aihubmix.com/v1",
)

completion = client.chat.completions.create(
    model="gemini-2.5-flash-preview-04-17",
    reasoning_effort="low", #"low", "medium", "high"는 1K, 8K, 16K 사고 토큰 예산에 매핑됩니다.
    messages=[
        {
            "role": "user",
            "content": "Explain the Occam's Razor concept and provide everyday examples of it"
        }
    ]
)

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

curl -X POST https://aihubmix.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-***" \
  -d '{
    "model": "gemini-2.5-flash-preview-04-17-nothink",
    "messages": [
      {
        "role": "user",
        "content": "Explain the Occam'\''s Razor concept and provide an everyday example of it."
      }
    ]
  }'

curl https://aihubmix.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer sk-***" \
-d '{
  "model": "gemini-2.5-pro-preview-05-06",
  "messages": [
    {
      "role": "user",
      "content": "Explain the Occam'\''s Razor concept and provide an everyday example of it."
    }
  ],
  "reasoning_effort": "low"
}'

복잡한 작업의 경우 모델 ID를 기본 gemini-2.5-flash-preview-04-17로 설정하여 사고를 활성화하기만 하면 됩니다.
Gemini 2.5 Flash는 budget 매개변수를 사용하여 사고의 깊이를 제어하며, 범위는 0에서 16K입니다. 기본 예산은 1024이며 최적의 한계 효과는 16K입니다.

미디어 이해

Aihubmix는 현재 inline_data를 통해 최대 20MB의 멀티미디어 파일(이미지, 오디오 및 비디오) 업로드를 지원합니다. 20MB를 초과하는 파일의 경우 파일 API가 필요합니다. 이 기능은 아직 사용할 수 없습니다. 진행 상황 추적 및 upload_url 검색은 개발 중입니다.

from google import genai
from google.genai import types

file_path = "yourpath/file.jpeg"
with open(file_path, "rb") as f:
    file_bytes = f.read()

client = genai.Client(
    api_key="sk-***", # AiHubMix에서 생성한 키로 교체
    http_options={"base_url": "https://aihubmix.com/gemini"}
)

response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=types.Content(
        parts=[
            types.Part(
                inline_data=types.Blob(
                    data=file_bytes,
                    mime_type="image/jpeg"
                )
            ),
            types.Part(
                text="Describe the image."
            )
        ]
    )
)

print(response.text)

from google import genai
from google.genai import types

file_path = "yourpath/file.m4a"
with open(file_path, "rb") as f:
    file_bytes = f.read()

client = genai.Client(
    api_key="sk-***", # AiHubMix에서 생성한 키로 교체
    http_options={"base_url": "https://aihubmix.com/gemini"}
)

response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=types.Content(
        parts=[
            types.Part(
                inline_data=types.Blob(
                    data=file_bytes,
                    mime_type="audio/m4a"
                )
            ),
            types.Part(
                text="Transcribe the audio to text."
            )
        ]
    )
)

print(response.text)

from google import genai
from google.genai import types

file_path = "yourpath/file.mp4"
with open(file_path, "rb") as f:
    file_bytes = f.read()

client = genai.Client(
    api_key="sk-***", # AiHubMix에서 생성한 키로 교체
    http_options={"base_url": "https://aihubmix.com/gemini"}
)

response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=types.Content(
        parts=[
            types.Part(
                inline_data=types.Blob(
                    data=file_bytes,
                    mime_type="video/mp4"
                )
            ),
            types.Part(
                text="Summarize this video. Then create a quiz with an answer key based on the information in this video."
            )
        ]
    )
)

print(response.text)

from google import genai
from google.genai import types

client = genai.Client(
    api_key="sk-***", # AiHubMix에서 생성한 키로 교체
    http_options={"base_url": "https://aihubmix.com/gemini"}
)

response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=types.Content(
        parts=[
            types.Part(
                file_data=types.FileData(
                    file_uri="https://www.youtube.com/watch?v=OoU7PwNyYUw"
                )
            ),
            types.Part(
                text="Please summarize the video in 3 sentences."
            )
        ]
    )
)

print(response.text)

코드 실행

코드 실행 기능을 사용하면 모델이 Python 코드를 생성 및 실행하고 최종 출력에 도달할 때까지 결과로부터 반복적으로 학습할 수 있습니다. 이 코드 실행 기능을 사용하여 코드 기반 추론의 이점을 활용하고 텍스트 출력을 생성하는 애플리케이션을 빌드할 수 있습니다. 예를 들어 방정식을 풀거나 텍스트를 처리하는 애플리케이션에서 코드 실행을 사용할 수 있습니다.

Python

from google import genai
from google.genai import types

file_path = "yourpath/file.csv"
with open(file_path, "rb") as f:
    file_bytes = f.read()

client = genai.Client(
    api_key="sk-***", # AiHubMix에서 생성한 키로 교체
    http_options={"base_url": "https://aihubmix.com/gemini"}
)

response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=types.Content(
        parts=[
            types.Part(
                inline_data=types.Blob(
                    data=file_bytes,
                    mime_type="text/csv"
                )
            ),
            types.Part(
                text="Please analyze this CSV and summarize the key statistics. Use code execution if needed."
            )
        ]
    ),
    config=types.GenerateContentConfig(
        tools=[types.Tool(
            code_execution=types.ToolCodeExecution
        )]
    )
)

for part in response.candidates[0].content.parts:
    if part.text is not None:
        print(part.text)
    if getattr(part, "executable_code", None) is not None:
        print("생성된 코드:\n", part.executable_code.code)
    if getattr(part, "code_execution_result", None) is not None:
        print("실행 결과:\n", part.code_execution_result.output)

Interactions API

Interactions는 Gemini의 차세대 추론 인터페이스로, 구조화된 Interaction 객체를 반환하며 텍스트 생성, 네이티브 이미지 생성(Nano Banana) 및 다단계 추론을 지원합니다. 동기 모드(interactions.create())와 비동기 모드(Background Interactions: create(background: true) + get / cancel / delete)를 모두 지원합니다.

SDK 버전 요구 사항: @google/genai >= 2.0.0(JS/TS) 또는 google-genai >= 2.0.0(Python). 낮은 버전의 SDK로 Interactions를 호출하면 Google 백엔드에서 거부됩니다(legacy Interactions schema no longer supported).

텍스트 생성

interactions.create()를 호출하여 추론을 시작하면, 반환된 Interaction 객체의 output_text 편의 속성을 사용할 수 있습니다.

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

const ai = new GoogleGenAI({
  apiKey: "sk-***", // AIHubMix에서 생성한 API Key로 교체
  httpOptions: { baseUrl: "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, ... }

from google import genai

client = genai.Client(
    api_key="sk-***",  # AIHubMix에서 생성한 API Key로 교체
    http_options={"base_url": "https://aihubmix.com/gemini"},
)

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

print(interaction.output_text)

네이티브 이미지 생성

response_format을 통해 출력 모달리티를 이미지로 설정하면, 반환된 Interaction 객체의 output_image 편의 속성을 사용할 수 있습니다.

추천 모델: gemini-3.1-flash-image(Nano Banana 2, 범용 이미지 생성 모델).
response_modalities 값은 반드시 소문자 ['text', 'image']여야 합니다. 대문자는 generateContent API의 형식이며, Interactions API에서는 400을 반환합니다.
delivery: 'inline'을 전달하지 마세요(400 Image delivery mode is not supported). 결과는 기본적으로 inline 방식으로 반환됩니다.

import { GoogleGenAI } from "@google/genai";
import fs from "node:fs";

const ai = new GoogleGenAI({
  apiKey: "sk-***", // AIHubMix에서 생성한 API Key로 교체
  httpOptions: { baseUrl: "https://aihubmix.com/gemini" },
});

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" },
});

// output_image 편의 속성(마지막 생성 이미지 가져오기)
if (interaction.output_image?.data) {
  fs.writeFileSync("output.png", Buffer.from(interaction.output_image.data, "base64"));
}

import base64
from google import genai

client = genai.Client(
    api_key="sk-***",  # AIHubMix에서 생성한 API Key로 교체
    http_options={"base_url": "https://aihubmix.com/gemini"},
)

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",
    },
)

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

스트리밍 출력

stream: true를 전달하여 SSE 스트리밍을 활성화합니다. 증분 텍스트는 event.delta.text를 통해 가져옵니다.

JavaScript

const stream = await ai.interactions.create({
  model: "gemini-3.5-flash",
  input: "Write a haiku about the moon",
  stream: true,
});

for await (const event of stream) {
  if (event.event_type === "step.delta" && event.delta?.type === "text") {
    process.stdout.write(event.delta.text);
  }
  if (event.event_type === "interaction.completed") {
    console.log("\nUsage:", JSON.stringify(event.interaction?.usage));
  }
}

비동기 모드(Background Interactions)

background: true를 전달하여 백그라운드 추론을 시작합니다. 요청은 즉시 Interaction 객체를 반환하며 status는 in_progress, id는 해당 작업의 핸들입니다. 모델은 백그라운드에서 추론을 계속합니다. interactions.get(id)로 폴링하여 결과를 가져오며, 3~5초 간격을 권장합니다. 시간이 오래 걸리는 추론에 적합하며 장시간 연결을 유지할 필요가 없습니다.

작업 결과가 아직 준비되지 않은 경우 get()은 400 또는 403을 반환합니다. 이는 생성이 아직 완료되지 않았다는 의미이므로 실패로 간주하여 중단하지 말고 계속 폴링하세요. 200이 반환될 때만 status가 종료 상태(completed / failed / cancelled)입니다.

JavaScript

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; // 결과가 준비되지 않았으므로 폴링 계속
  }
}

console.log(result.output_text);
await ai.interactions.delete(task.id); // 종료 상태 결과를 이미 가져왔으므로 안전하게 삭제

id는 iact1_로 시작합니다. 그대로 저장하고 이후의 get / cancel / delete 호출에 모두 사용하세요. 잘라내거나 변형하지 마세요.
작업 실행 중에는 모델 제공업체가 cancel 요청을 받아들이지 않고 403을 반환합니다. delete는 작업이 종료 상태에 도달하기 전에는 409를 반환하므로, 먼저 get()으로 종료 상태 결과를 가져온 뒤 삭제하세요.
background와 stream은 함께 사용할 수 없으며, 이미지 모델(예: gemini-3.1-flash-image)은 비동기 모드를 지원하지 않습니다.

전체 SDK 가이드는 Gemini 네이티브 SDK 통합을 참조하세요.

컨텍스트 캐싱

Gemini의 네이티브 API는 기본적으로 암시적 컨텍스트 캐싱을 활성화하므로 설정이 필요하지 않습니다. 모든 generate_content 요청에 대해 시스템은 자동으로 입력 콘텐츠를 캐시합니다. 후속 요청이 정확히 동일한 콘텐츠, 모델 및 매개변수를 사용하는 경우 시스템은 즉시 이전 결과를 반환하여 응답 시간을 크게 단축하고 잠재적으로 입력 토큰 비용을 절감합니다.

캐싱은 자동이며 수동 구성이 필요하지 않습니다.
캐시는 콘텐츠, 모델 및 모든 매개변수가 정확히 동일할 때만 적중됩니다. 어떤 차이라도 캐시 미스를 초래합니다.
캐시 TTL(Time-To-Live)은 개발자가 설정하거나 설정하지 않은 상태로 둘 수 있습니다(기본값 1시간). Google에서 적용하는 최소 또는 최대 TTL은 없습니다. 비용은 캐시된 토큰 수와 캐시 기간에 따라 다릅니다.
- Google은 TTL에 제한을 두지 않지만 전달 플랫폼으로서 제한된 TTL 범위만 지원합니다. 플랫폼의 한계를 넘어서는 요구 사항에 대해서는 문의해 주십시오.

참고

비용 절감 보장 없음: 캐시 토큰은 표준 입력 가격의 25%로 청구되므로 이론적으로 캐싱은 입력 토큰 비용을 최대 75%까지 절약할 수 있습니다. 그러나 Google의 공식 문서는 비용 절감을 보장하지 않습니다. 실제 효과는 캐시 적중률, 토큰 유형 및 저장 기간에 따라 다릅니다.
캐시 적중 조건: 캐시 효율성을 극대화하려면 입력 시작 부분에 반복 가능한 컨텍스트를 배치하고 끝 부분에 동적 콘텐츠(예: 사용자 입력)를 배치하십시오.
캐시 적중 감지 방법: 응답이 캐시에서 온 경우 response.usage_metadata에 cache_tokens_details 필드와 cached_content_token_count가 포함됩니다. 이를 사용하여 캐시 사용량을 확인할 수 있습니다.
캐시 적중 시 예제 필드:
cache_tokens_details=[ModalityTokenCount(modality=<MediaModality.TEXT: 'TEXT'>, token_count=2003)] cached_content_token_count=2003

코드 예제:

from google import genai

client = genai.Client(
    http_options={"base_url": "https://aihubmix.com/gemini"},
    api_key="sk-***",  # AiHubMix API 키로 교체
)

prompt = """
Call me Ishmael. Some years ago—never mind how long precisely—having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world. It is a way I have of driving off the spleen and regulating the circulation. Whenever I find myself growing grim about the mouth; whenever it is a damp, drizzly November in my soul; whenever I find myself involuntarily pausing before coffin warehouses, and bringing up the rear of every funeral I meet; and especially whenever my hypos get such an upper hand of me, that it requires a strong moral principle to prevent me from deliberately stepping into the street, and methodically knocking people's hats off—then, I account it high time to get to sea as soon as I can. This is my substitute for pistol and ball. With a philosophical flourish Cato throws himself upon his sword; I quietly take to the ship. There is nothing surprising in this. If they but knew it, almost all men in their degree, some time or other, cherish very nearly the same feelings towards the ocean with me. There now is your insular city of the Manhattoes, belted round by wharves as Indian isles by coral reefs—commerce surrounds it with her surf. Right and left, the streets take you waterward.
"""

def generate_content_sync():
    response = client.models.generate_content(
        model="gemini-2.5-flash-preview-05-20",
        contents=prompt + "How many sentences are in this passage? ",
    )
    print(response.usage_metadata)  # 캐시가 적중되면 cache_tokens_details와 cached_content_token_count가 나타납니다.
    return response

generate_content_sync()

캐시가 적중되면 response.usage_metadata에 다음이 포함됩니다:
cache_tokens_details=[ModalityTokenCount(modality=<MediaModality.TEXT: 'TEXT'>, token_count=2003)]
cached_content_token_count=2003

핵심 결론: 암시적 캐싱은 자동이며 명확한 캐시 적중 피드백을 제공합니다. 개발자는 usage_metadata에서 캐시 상태를 확인할 수 있습니다. 비용 절감은 보장되지 않으며 실제 이점은 요청 구조와 캐시 적중률에 따라 다릅니다.

함수 호출

openai 호환 방식을 사용하여 Gemini의 함수 호출을 호출하려면 요청 본문에 tool_choice="auto"를 전달해야 합니다. 그렇지 않으면 오류가 발생합니다.

from openai import OpenAI

# 모델에 대한 함수 선언 정의
schedule_meeting_function = {
    "name": "schedule_meeting",
    "description": "지정된 시간에 지정된 참석자와 회의를 예약합니다.",
    "parameters": {
        "type": "object",
        "properties": {
            "attendees": {
                "type": "array",
                "items": {"type": "string"},
                "description": "회의에 참석하는 사람들의 목록입니다.",
            },
            "date": {
                "type": "string",
                "description": "회의 날짜 (예: '2024-07-29')",
            },
            "time": {
                "type": "string",
                "description": "회의 시간 (예: '15:00')",
            },
            "topic": {
                "type": "string",
                "description": "회의의 주제 또는 주제입니다.",
            },
        },
        "required": ["attendees", "date", "time", "topic"],
    },
}

# 클라이언트 구성
client = OpenAI(
    api_key="AIHUBMIX_API_KEY", # AiHubMix에서 생성한 키로 교체
    base_url="https://aihubmix.com/v1",
)

# OpenAI 호환 형식을 사용하여 함수 선언으로 요청 보내기
response = client.chat.completions.create(
    model="gemini-2.0-flash",
    messages=[
        {"role": "user", "content": "Schedule a meeting with Bob and Alice for 03/14/2025 at 10:00 AM about the Q3 planning."}
    ],
    tools=[{"type": "function", "function": schedule_meeting_function}],
    tool_choice="auto" ## 📍 Aihubmix 호환성 추가, 더 안정적인 요청 방법
)

# 함수 호출 확인
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    function_call = tool_call.function
    print(f"호출할 함수: {function_call.name}")
    print(f"인수: {function_call.arguments}")
    print(response.usage)
    #  실제 앱에서는 여기에서 함수를 호출합니다:
    #  result = schedule_meeting(**json.loads(function_call.arguments))
else:
    print("응답에서 함수 호출을 찾을 수 없습니다.")
    print(response.choices[0].message.content)

출력 예:

호출할 함수: schedule_meeting
인수: {"attendees":["Bob","Alice"],"date":"2025-03-14","time":"10:00","topic":"Q3 planning"}
CompletionUsage(completion_tokens=28, prompt_tokens=111, total_tokens=139, completion_tokens_details=None, prompt_tokens_details=None)

토큰 사용량 추적 간소화

Gemini는 usage_metadata를 사용하여 토큰 사용량을 추적합니다. 각 필드의 의미는 다음과 같습니다:
- prompt_token_count: 입력 토큰 수
- candidates_token_count: 출력 토큰 수
- thoughts_token_count: 추론 중에 사용된 토큰 (출력으로도 계산됨)
- total_token_count: 총 사용된 토큰 (입력 + 출력)
자세한 내용은 공식 문서를 확인하십시오.
OpenAI 호환 형식을 사용하는 API의 경우 토큰 사용량은 다음 필드와 함께 .usage 아래에서 추적됩니다:
- usage.completion_tokens: 입력 토큰 수
- usage.prompt_tokens: 출력 토큰 수 (추론 포함)
- usage.total_tokens: 총 토큰 사용량

코드에서 사용하는 방법은 다음과 같습니다:

from google import genai
from google.genai import types
import time

def generate():
    client = genai.Client(
        api_key="sk-***", # AiHubMix의 키로 교체
        http_options={"base_url": "https://aihubmix.com/gemini"},
    )

    model = "gemini-2.5-pro-preview-03-25"
    contents = [
        types.Content(
            role="user",
            parts=[
                types.Part.from_text(text="""How is the Rule of 72 in finance derived?"""),
            ],
        ),
    ]
    generate_content_config = types.GenerateContentConfig(
        response_mime_type="text/plain",
    )

    final_usage_metadata = None
    
    for chunk in client.models.generate_content_stream(
        model=model,
        contents=contents,
        config=generate_content_config,
    ):
        print(chunk.text, end="")
        if chunk.usage_metadata:
            final_usage_metadata = chunk.usage_metadata
    
    # 모든 청크가 처리되면 전체 토큰 사용량을 인쇄합니다.
    if final_usage_metadata:
        print(f"\n사용량: {final_usage_metadata}")

if __name__ == "__main__":
    generate()

from openai import OpenAI

client = OpenAI(
    api_key="sk-***", # AiHubMix의 키로 교체
    base_url="https://aihubmix.com/v1",
)

completion = client.chat.completions.create(
    model="gemini-2.5-flash-preview-04-17",
    reasoning_effort="low", #"low", "medium", "high"는 내부적으로 1K, 8K, 24K 사고 토큰 예산에 매핑됩니다. 사고를 비활성화하려면 추론 노력을 "none"으로 설정할 수 있습니다.
    messages=[
        {
            "role": "user",
            "content": "How is the Rule of 72 in finance derived?"
        }
    ],
    stream=True
)

#print(completion.choices[0].message.content)

for chunk in completion:
    print(chunk.choices[0].delta)
    # 마지막 청크에만 토큰 사용량 정보를 인쇄합니다 (전체 사용량 데이터 포함)
    if chunk.usage and chunk.usage.completion_tokens > 0:
        print(f"출력 토큰: {chunk.usage.completion_tokens}")
        print(f"입력 토큰: {chunk.usage.prompt_tokens}")
        print(f"총 토큰: {chunk.usage.total_tokens}")

마지막 업데이트: 2026-08-14

시작하기

게이트웨이 기능

모델 기능

프로토콜 참조

플랫폼 관리

개인정보 및 약관

Gemini 모델 전달

Gemini 2.5 추론 모델 정보

Gemini 2.5 Flash: 빠른 작업 지원

미디어 이해

코드 실행

Interactions API

텍스트 생성

네이티브 이미지 생성

스트리밍 출력

비동기 모드(Background Interactions)

컨텍스트 캐싱

참고

함수 호출

토큰 사용량 추적 간소화

​Gemini 모델 전달

​Gemini 2.5 추론 모델 정보

​Gemini 2.5 Flash: 빠른 작업 지원

​미디어 이해

​코드 실행

​Interactions API

​텍스트 생성

​네이티브 이미지 생성

​스트리밍 출력

​비동기 모드(Background Interactions)

​컨텍스트 캐싱

​참고

​함수 호출

​토큰 사용량 추적 간소화

Gemini 모델 전달

Gemini 2.5 추론 모델 정보

Gemini 2.5 Flash: 빠른 작업 지원

미디어 이해

코드 실행

Interactions API

텍스트 생성

네이티브 이미지 생성

스트리밍 출력

비동기 모드(Background Interactions)

컨텍스트 캐싱

참고

함수 호출

토큰 사용량 추적 간소화