devkuma – Gemini

What Is Gemini?

kc@example.com (kc kim) — Sat, 30 Aug 2025 17:05:00 +0900

What Is Google Gemini?

Gemini is a multimodal large language model (LLM) developed by Google by integrating the capabilities of the DeepMind and Brain teams.
Its key feature is that it can understand and process many forms of information, including text, audio, images, and video.
It was first released in December 2023, and Gemini 1.0 launched in three versions: Ultra, Pro, and Nano. These targeted complex tasks, general-purpose tasks, and on-device processing respectively.
It has continued to evolve rapidly, and Gemini 2.5 Flash and 2.5 Pro are currently used as major versions. Flash focuses on response speed, while Pro provides advanced reasoning and code generation capabilities, with improved audio output and security features.
https://gemini.google.com/

Main Features of Gemini

Multimodality

Unlike earlier AI models that were mainly limited to text, Gemini can understand and process text, images, audio, and video together in an integrated way.
For example, users can ask questions while watching a video or provide images and text together to request a specific task.

Image Editing (Nano-Banana / Gemini 2.5 Flash Image)

The Gemini 2.5 Flash Image model, called “Nano-Banana,” lets users edit or composite images with natural language and provides advanced features that preserve characteristics such as faces and objects consistently.
For example, it can combine multiple images, change backgrounds, and modify styles or clothing. AI-generated images include visible or invisible watermarks so generation can be verified.

Voice and Voice Interaction

The Gemini Live feature is a real-time conversational interface using voice, and it can be used with screen and camera sharing, especially on Pixel 9.

Various Models

Gemini is divided into several models depending on the purpose of use.
- Gemini Ultra: The most powerful model optimized for complex tasks.
- Gemini Pro: A balanced-performance model that can be used for a wide range of tasks.
- Gemini Flash: A model suitable for tasks where cost efficiency and fast response speed are important.

Strong Performance

Gemini shows excellent performance in many benchmarks, including complex reasoning, coding, and math problem solving. In particular, it has also shown results surpassing human expert scores on the Massive Multitask Language Understanding (MMLU) benchmark.

Enhanced Everyday Assistant Role

Gemini for Home is a new AI-based life assistant replacing Google Assistant. It includes daily routine management, more natural conversation, and smart home device control. Early access is scheduled to begin in October 2025.
Gemini is also integrated into Android Auto, allowing users to send messages, check email, and perform various tasks with voice commands while driving.

Google Workspace Integration and Multilingual Support

Gemini connects Gmail, Calendar, Maps, Photos, YouTube, and more, helping users work across multiple apps. It also provides features such as schedule management, alarm setting, calls, and presentation practice.
It currently supports more than 40 languages and can be used through mobile apps (Android, iOS) and the web. Gemini 2.5 Flash and 2.5 Pro are also provided as paid usage-based models.

Use Cases

Gemini can be used in many fields, including:
- Creative work: Writing, image generation, idea brainstorming, and more
- Learning and research: Summarizing complex topics, analyzing papers, creating study plans, and more
- Coding: Code generation, debugging, optimization, and more
- Customer service: Providing accurate and useful answers to questions

Gemini can be used with various Google cloud services such as Google AI Studio and Vertex AI, and it is also embedded in Google’s AI assistant, Gemini.

Competitiveness and Comparison Points

Google has announced that Gemini delivers benchmark performance similar to or higher than OpenAI’s GPT-4, but actual user experience may differ by use case.
Gemini is especially differentiated by its multimodal design, long context window, and enhanced image and voice processing capabilities.

Summary

Area	Feature Summary
Multimodal processing	Can understand and generate text, images, audio, video, and code
Model lineup	Gemini 1.0 (Ultra/Pro/Nano) -> latest versions such as 2.5 Flash / Pro
Image editing	Nano-Banana: natural language-based editing with consistent feature preservation
Voice interface	Gemini Live: voice-based real-time conversation
Everyday assistant features	Gemini for Home, Android Auto voice support
Workspace integration	Integrated with Gmail, Calendar, and more; can connect multiple apps
Competitiveness	Multimodal design, long context, and high benchmarks compared with GPT-4
Pricing model	Free + premium plans, such as Gemini 2.5 Pro

Future Direction

Gemini is expected to be deeply integrated into many areas, including smart homes, vehicles, productivity tools, and multimedia generation, and new features and versions continue to be released.

Building an Application with the Gemini API

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

Issuing a Gemini Key

To use the Google Gemini API, you need to issue an API key.

1. Access the Gemini Developer API Site

Go to https://ai.google.dev/ and click the Explore models in Google AI Studio button.
On first access, the terms of service are displayed. Review them and click the “Continue” button.

2. Issue a Get API Key

Select the Get API Key menu to issue a key.
If you have already issued one, it will appear in the list. If you have not, you can use the Create API key button.

Free Tier

The free tier has usage limits by model. For gemini-3-flash, the daily maximum number of requests (RPD) is only up to 20.

Client Development Using a Library

Here, we will look at how to call the API using the Google GenAI SDK with Kotlin.

Project Creation

Create a project using an IDE tool.

.
├── 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

Adding the Library

/build.gradle.kts

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

Check the GitHub repository (googleapis/java-genai) and use the latest version.

Client Development

/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",
            "Explain artificial intelligence in one sentence.",
            null
        )

    println(response.text())
}

Output:

Artificial intelligence is technology that implements human learning, reasoning, and perception abilities in computer systems so machines can perform intelligent tasks.

Put your issued key in GEMINI_API_KEY.

REST

The Gemini API can also be called as a 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": "Explain artificial intelligence in one sentence."
          }
        ]
      }
    ]
  }'

output:

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": "Artificial intelligence is technology that implements human learning, reasoning, and perception abilities in computer systems so they can perform intelligent tasks.",
            "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"
}

References

Gemini API | Google AI for Developers

The example code above can be found on GitHub.

MCP Function Calling with the Google Gemini API

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

How Function Calling Works

The details of how function calling works are explained in the official Gemini API documentation.

In brief:

Function calling is a structured collaboration method among an application, an LLM, and external functions.
The application first defines function declarations to describe the function name, parameters, and purpose to the model.
When the user prompt and function declarations are passed to the LLM, the model decides whether a function call is needed and returns a structured JSON response or a regular text response.
Function execution is the responsibility of the application, not the model. The model only provides the function name and arguments.
When the execution result is sent back to the model, the model reflects it and generates a user-friendly final answer.

Preparing the MCP Server

We will use the simple server described in the following document.
Adding Authentication to a WebMVC MCP Server Built with Spring and Kotlin

Client Development

The client will use the application created in the following document.
Building an Application with the 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() {
    // Configuration
    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. Initialize MCP client
    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()

    // Fetch the list of tools available from the MCP server.
    val toolsList = mcpClient.listTools()
    println("Available Tools = $toolsList")


    // 2. Initialize Gemini client and configure functions
    val functionDeclarations = toolsList.tools().stream()
        .map({ t ->
            FunctionDeclaration.builder()
                .name(t.name()) // MCP tool name
                .description(t.description()) // MCP tool description
                .parametersJsonSchema(t.inputSchema()) // Receive as Object type
                .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. Process user question
    val userMessage = "Tell me the weather in Seoul"
    println("\n========================================")
    println("User: $userMessage")
    println("========================================\n")



    // 5. First Gemini API call
    var response = client.models.generateContent(
        "gemini-3-flash-preview",
        userMessage,
        config
    )

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

    // 6. Check and process 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")

                    // Check whether there is a Function Call
                    val functionCalls = parts.filter { p: Part ->
                        p.functionCall() != null && p.functionCall().isPresent
                    }

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

                        // Build conversation history (user message + model function call)
                        val contents = mutableListOf<Content>()

                        // Add user message
                        contents.add(
                            Content.builder()
                                .role("user")
                                .parts(listOf(Part.builder().text(userMessage).build()))
                                .build()
                        )

                        // Add model response (function call)
                        contents.add(content)

                        // Process each 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")

                                    // Step 3: Call the tool on the MCP server
                                    val mcpResult = mcpClient.callTool(CallToolRequest(functionName, functionArgs))
                                    println("MCP Result: $mcpResult")

                                    // Extract content from MCP result
                                    val mcpContent = mcpResult.content()
                                    val resultText = if (mcpContent.isNotEmpty()) {
                                        // Convert MCP Content to string
                                        // TextContent has a text field
                                        val content = mcpContent[0]
                                        when {
                                            content is io.modelcontextprotocol.spec.McpSchema.TextContent -> {
                                                content.text()
                                            }

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

                                    println("Extracted Result: $resultText")

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

                                    functionResponseParts.add(functionResponsePart)
                                }
                            }
                        }

                        // Add function response as user role
                        contents.add(
                            Content.builder()
                                .role("user")
                                .parts(functionResponseParts)
                                .build()
                        )

                        // Step 4: Call Gemini API again with function call results
                        println("\n=== Calling Gemini Again with Function Results ===")

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

                        // 7. Print final response
                        println("\n=== Final Response ===")
                        println("Assistant: ${response.text()}")
                    } else {
                        println("\nNo function calls detected. Direct response: ${response.text()}")
                    }
                }
            }
        }
    }

    // 8. Cleanup: close MCP client
    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: Tell me the weather in Seoul
========================================

=== 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: The weather in Seoul is good.

References

Gemini API | Function calling with the Gemini API