devkuma – Kotlin

Gemini APIを活用したアプリケーション作成

kc@example.com (kc kim) — Wed, 28 Jan 2026 18:08:00 +0900

Gemini Keyの発行

Google Gemini APIを使用するには、API Keyを発行する必要がある。

1. Gemini Developer APIサイトにアクセス

https://ai.google.dev/ にアクセスし、Explore models in Google AI Studioボタンをクリックする。
初回アクセス時は利用規約が表示されるため、内容を確認して「Continue」ボタンをクリックする。

2. Get API Keyの発行

Get API Keyメニューを選択すると、Keyを発行できる。
すでに発行済みなら一覧に表示され、発行したことがなければAPIキーを作成ボタンで発行できる。

無料枠

無料枠はモデルごとに使用量制限がある。 gemini-3-flash基準で、1日の最大リクエスト数（RPD）は最大20回しかない。

ライブラリを活用したクライアント開発

ここではKotlin言語でGoogle GenAI SDKを活用し、APIを呼び出す方法を見ていく。

プロジェクト作成

IDEツールを利用してプロジェクトを作成する。

.
├── build.gradle.kts
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradle.properties
├── gradlew
├── gradlew.bat
├── settings.gradle.kts
└── src
    ├── main
    │   ├── kotlin
    │   │   └── Main.kt
    │   └── resources
    └── test
        ├── kotlin
        └── resources

ライブラリ追加

/build.gradle.kts

dependencies {
    implementation("com.google.genai:google-genai:1.36.0")
}

バージョンはGitHubリポジトリ（googleapis/java-genai）を確認し、最新バージョンを入れればよい。

クライアント開発

/src/main/kotlin/Main.kt

package com.devkuma

import com.google.genai.Client

fun main() {
    val client = Client.builder().apiKey("GEMINI_API_KEY").build()

    val response =
        client.models.generateContent(
            "gemini-3-flash-preview",
            "人工知能について一文で説明してください。",
            null
        )

    println(response.text())
}

Output:

人工知能は、人間の学習、推論、知覚能力をコンピューターシステムで実装し、機械が知的な作業を実行できるようにする技術です。

GEMINI_API_KEYには発行したキーを入れる。

REST

Gemini APIはREST APIとして呼び出すこともできる。

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [
      {
        "parts": [
          {
            "text": "人工知能について一文で説明してください。"
          }
        ]
      }
    ]
  }'

output:

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": "人工知能は、人間の学習、推論、知覚能力をコンピューターシステムで実装し、知的な作業を実行できるようにした技術です。",
            "thoughtSignature": "Er8OCrwOAXLI2nzqxL3K8LCAB020BPaY+sv89...."
          }
        ],
        "role": "model"
      },
      "finishReason": "STOP",
      "index": 0
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 13,
    "candidatesTokenCount": 32,
    "totalTokenCount": 415,
    "promptTokensDetails": [
      {
        "modality": "TEXT",
        "tokenCount": 13
      }
    ],
    "thoughtsTokenCount": 370
  },
  "modelVersion": "gemini-3-flash-preview",
  "responseId": "5rh6afO6NYb22roPsKr06Ao"
}

参考文書

Gemini API | Google AI for Developers

上記のサンプルコードはGitHubで確認できる。

Google Gemini APIを使用したMCP関数呼び出し

kc@example.com (kc kim) — Fri, 30 Jan 2026 16:28:00 +0900

関数呼び出しの動作方式

関数呼び出しの動作方式については、Gemini API公式文書に詳しく説明されている。

簡単に説明すると次のとおりである。

関数呼び出しは、アプリケーション、LLM、外部関数の間の構造化された協業方式である。
アプリケーションはまず関数宣言を定義し、関数名、パラメーター、目的をモデルに説明する準備をする。
ユーザープロンプトと関数宣言を一緒にLLMへ渡すと、モデルは関数呼び出しが必要か判断し、構造化されたJSON応答または通常テキストで応答する。
関数実行はモデルではなくアプリケーションの責任であり、モデルは関数名と引数だけを提供する。
実行結果を再びモデルに送ると、モデルはそれを反映してユーザーに分かりやすい最終回答を生成する。

MCPサーバーの準備

MCPサーバーは次の文書で説明した簡単なサーバーを活用する。
Spring、Kotlinを活用して作ったWebMVC MCP Serverに認証を追加する

クライアント開発

クライアントは次の文書で作成したアプリケーションを活用する。
Gemini APIを活用したアプリケーション作成

package com.devkuma.sample1

import com.google.genai.Client
import com.google.genai.types.*
import io.modelcontextprotocol.client.McpClient
import io.modelcontextprotocol.client.transport.HttpClientStreamableHttpTransport
import io.modelcontextprotocol.spec.McpSchema.CallToolRequest
import java.net.http.HttpRequest
import java.util.stream.Collectors


fun main() {
    // 設定
    val mcpServerUrl = "http://localhost:8080"
    val mcpApiKey = "api01.mycustomapikey"
    val geminiApiKey = "GEMINI_API_KEY"

    println("========================================")
    println("Gemini API + MCP Function Calling Demo")
    println("========================================\n")

    // 1. MCPクライアント初期化
    val request = HttpRequest.newBuilder()
        .header("Content-Type", "application/json")
        .header("X-API-key", mcpApiKey)

    val transport = HttpClientStreamableHttpTransport.builder(mcpServerUrl)
        .requestBuilder(request)
        .build()

    val mcpClient = McpClient.sync(transport)
        .build()
    mcpClient.initialize()
    mcpClient.ping()

    // MCPサーバーで使用可能なツール一覧を取得する。
    val toolsList = mcpClient.listTools()
    println("Available Tools = $toolsList")


    // 2. Geminiクライアント初期化および関数設定
    val functionDeclarations = toolsList.tools().stream()
        .map({ t ->
            FunctionDeclaration.builder()
                .name(t.name()) // MCP tool name
                .description(t.description()) // MCP tool description
                .parametersJsonSchema(t.inputSchema()) // Object型で受け取る
                .build()
        })
        .collect(Collectors.toList())

    val tool: Tool = Tool.builder()
        .functionDeclarations(functionDeclarations)
        .build()

    val config = GenerateContentConfig.builder()
        .tools(listOf(tool))
        .build()

    val client = Client.builder().apiKey(geminiApiKey).build()

    // 4. ユーザー質問処理
    val userMessage = "ソウルの天気を教えて"
    println("\n========================================")
    println("User: $userMessage")
    println("========================================\n")



    // 5. 最初のGemini API呼び出し
    var response = client.models.generateContent(
        "gemini-3-flash-preview",
        userMessage,
        config
    )

    println("\n=== First Response ===")
    println("Candidates: ${response.candidates()}")

    // 6. Function Call確認および処理
    val candidatesOpt = response.candidates()
    if (candidatesOpt.isPresent) {
        val candidates = candidatesOpt.get()
        if (candidates.isNotEmpty()) {
            val candidate = candidates[0]
            val contentOpt = candidate.content()

            if (contentOpt.isPresent) {
                val content = contentOpt.get()
                val partsOpt = content.parts()

                if (partsOpt.isPresent) {
                    val parts = partsOpt.get()
                    println("Parts: $parts")

                    // Function Callがあるか確認
                    val functionCalls = parts.filter { p: Part ->
                        p.functionCall() != null && p.functionCall().isPresent
                    }

                    if (functionCalls.isNotEmpty()) {
                        println("\n=== Function Calls Detected ===")

                        // 会話履歴を構成（ユーザーメッセージ + モデルのfunction call）
                        val contents = mutableListOf<Content>()

                        // ユーザーメッセージを追加
                        contents.add(
                            Content.builder()
                                .role("user")
                                .parts(listOf(Part.builder().text(userMessage).build()))
                                .build()
                        )

                        // モデルの応答（function call）を追加
                        contents.add(content)

                        // 各Function Callを処理
                        val functionResponseParts = mutableListOf<Part>()

                        for (part in functionCalls) {
                            val functionCallOpt = part.functionCall()
                            if (functionCallOpt.isPresent) {
                                val functionCall = functionCallOpt.get()
                                val functionNameOpt = functionCall.name()
                                val functionArgsOpt = functionCall.args()

                                if (functionNameOpt.isPresent && functionArgsOpt.isPresent) {
                                    val functionName = functionNameOpt.get()
                                    val functionArgs = functionArgsOpt.get()

                                    println("Function Call: $functionName")
                                    println("Arguments: $functionArgs")

                                    // 3段階: MCPサーバーのツールを呼び出し
                                    val mcpResult = mcpClient.callTool(CallToolRequest(functionName, functionArgs))
                                    println("MCP Result: $mcpResult")

                                    // MCP結果からcontentを抽出
                                    val mcpContent = mcpResult.content()
                                    val resultText = if (mcpContent.isNotEmpty()) {
                                        // MCP Contentを文字列に変換
                                        // TextContentの場合はtextフィールドを持つ
                                        val content = mcpContent[0]
                                        when {
                                            content is io.modelcontextprotocol.spec.McpSchema.TextContent -> {
                                                content.text()
                                            }

                                            else -> content.toString()
                                        }
                                    } else {
                                        "No result"
                                    }

                                    println("Extracted Result: $resultText")

                                    // Function Response Partを生成
                                    val functionResponsePart = Part.builder()
                                        .functionResponse(
                                            FunctionResponse.builder()
                                                .name(functionName)
                                                .response(mapOf("result" to resultText))
                                                .build()
                                        )
                                        .build()

                                    functionResponseParts.add(functionResponsePart)
                                }
                            }
                        }

                        // 関数応答をuser roleとして追加
                        contents.add(
                            Content.builder()
                                .role("user")
                                .parts(functionResponseParts)
                                .build()
                        )

                        // 4段階: 関数呼び出し結果を含めてGemini APIを再呼び出し
                        println("\n=== Calling Gemini Again with Function Results ===")

                        response = client.models.generateContent(
                            "gemini-3-flash-preview",
                            contents,
                            config
                        )

                        // 7. 最終応答出力
                        println("\n=== Final Response ===")
                        println("Assistant: ${response.text()}")
                    } else {
                        println("\nNo function calls detected. Direct response: ${response.text()}")
                    }
                }
            }
        }
    }

    // 8. 整理: MCPクライアント終了
    mcpClient.closeGracefully()
}

Output:

========================================
Gemini API + MCP Function Calling Demo
========================================

Available Tools = ListToolsResult[tools=[Tool[name=get_weather, title=null, description=Return the weather of a given city., inputSchema=JsonSchema[type=object, properties={city={type=string, description=The city for which to get the weather}}, required=[city], additionalProperties=false, defs=null, definitions=null], outputSchema=null, annotations=null, meta=null]], nextCursor=null, meta=null]

========================================
User: ソウルの天気を教えて
========================================

=== First Response ===
Candidates: Optional[[Candidate{content=Optional[Content{parts=Optional[[Part{mediaResolution=Optional.empty, codeExecutionResult=Optional.empty, executableCode=Optional.empty, fileData=Optional.empty, functionCall=Optional[FunctionCall{id=Optional.empty, args=Optional[{city=Seoul}], name=Optional[get_weather], partialArgs=Optional.empty, willContinue=Optional.empty}], functionResponse=Optional.empty, inlineData=Optional.empty, text=Optional.empty, thought=Optional.empty, thoughtSignature=Optional[[B@a7f0ab6], videoMetadata=Optional.empty}]], role=Optional[model]}], citationMetadata=Optional.empty, finishMessage=Optional.empty, tokenCount=Optional.empty, finishReason=Optional[STOP], avgLogprobs=Optional.empty, groundingMetadata=Optional.empty, index=Optional[0], logprobsResult=Optional.empty, safetyRatings=Optional.empty, urlContextMetadata=Optional.empty}]]
Parts: [Part{mediaResolution=Optional.empty, codeExecutionResult=Optional.empty, executableCode=Optional.empty, fileData=Optional.empty, functionCall=Optional[FunctionCall{id=Optional.empty, args=Optional[{city=Seoul}], name=Optional[get_weather], partialArgs=Optional.empty, willContinue=Optional.empty}], functionResponse=Optional.empty, inlineData=Optional.empty, text=Optional.empty, thought=Optional.empty, thoughtSignature=Optional[[B@a7f0ab6], videoMetadata=Optional.empty}]

=== Function Calls Detected ===
Function Call: get_weather
Arguments: {city=Seoul}
MCP Result: CallToolResult[content=[TextContent[annotations=null, text="The weather in Seoul is good.", meta=null]], isError=false, structuredContent=null, meta=null]
Extracted Result: "The weather in Seoul is good."

=== Calling Gemini Again with Function Results ===

=== Final Response ===
Assistant: ソウルの天気は良いです。

参考文書

Gemini API | Gemini APIを使用した関数呼び出し