devkuma – AI

OpenAI ChatGPT Explained

kc@example.com (kc kim) — Sun, 26 Apr 2026 15:49:00 +0900

What Is ChatGPT?

ChatGPT is a conversational artificial intelligence system developed by OpenAI. Its purpose is to understand human language and generate natural responses. Unlike simple search-based services, it is distinguished by its ability to understand the user’s intent and provide more sophisticated answers that reflect context.

Concept and Background of ChatGPT

Artificial intelligence technology has developed for a long time, and the field of natural language processing (NLP) has grown especially rapidly in recent years. ChatGPT emerged in this flow and focuses on implementing human-like conversation based on a large language model (LLM).

Where traditional search engines list information around keywords, ChatGPT understands the context of a question and generates a complete answer. In other words, it is closer to a technology that “understands and reconstructs” information than simply “finding” it.

How ChatGPT Works

At the core of ChatGPT is an AI model trained on massive amounts of text data. This model learns the relationships and flow among words in sentences and operates by predicting the words or sentences most likely to come next when a particular sentence is given.

For example, when a user enters a question, ChatGPT analyzes the meaning of the sentence and selects the most natural and appropriate sentences from many possibilities to compose a suitable answer. This process happens in a very short time and gives the user an experience similar to talking with a person.

Main Features

Natural Conversational Ability

ChatGPT does not merely generate sentences. It can remember the context of previous conversation and continue the discussion. This allows users to ask follow-up questions on a single topic and gradually receive deeper answers.

Broad Usability

This system is not limited to a specific field and can be used across a very wide range of areas. Representative uses include:

Blog and content writing
Programming code generation and debugging
Document summarization and translation
Learning support and concept explanation
Idea generation and planning support

In this way, ChatGPT is used as a productivity-enhancing tool in many environments, from individual users to companies.

Fast Response Speed

Because it can generate answers to complex questions in a short time, it is also valuable as a real-time communication tool.

Advantages of ChatGPT

The greatest advantage of ChatGPT is that it goes beyond simply providing information and reconstructs it in an easy-to-understand form. This is especially helpful in fields that require specialized knowledge.

It can also automate repetitive tasks or quickly generate drafts when ideas are needed, greatly improving work efficiency. This is why many users, including developers, writers, marketers, and students, actively use it.

Limitations and Precautions

However, ChatGPT is not a perfect system. It also has several limitations.

First, not every answer can be guaranteed to be correct. Because the model generates sentences probabilistically, it may include content that differs from actual facts. Second, reflection of the latest information may be limited. Third, in areas requiring professional judgment such as law, medicine, and finance, it should be used as reference material, and additional verification is essential.

Therefore, when using ChatGPT, users should critically review the results and check important information through separate reliable sources.

Conclusion

ChatGPT can be considered a next-generation AI tool that goes beyond a simple chatbot, understands human language, and generates new information based on it. In particular, because anyone can easily access it through a conversational interface, it is expected to bring major changes to the way information is used.

As artificial intelligence technology continues to advance, systems like ChatGPT will play a key role not only in everyday life but also in various industries. In this flow, it is also important for users to develop the ability to understand and use the tool properly.

OpenAI

kc@example.com (kc kim) — Sun, 26 Apr 2026 15:45:00 +0900

An introduction to OpenAI

Claude Explained

kc@example.com (kc kim) — Fri, 07 Nov 2025 11:51:00 +0900

Overview

Claude is part of the artificial intelligence (AI) language model (LLM) family and was developed by the U.S. AI research company Anthropic.
It was first released in March 2023 and has since evolved through several versions, including Claude 2, Claude 3, and Claude 4.
One development goal is safety and responsible AI use, and for this it adopts the “Constitutional AI” approach.
The name Claude comes from Claude Shannon, the French mathematician and pioneer of information theory.
Like ChatGPT, it is a conversational AI model that performs text-based conversation, summarization, translation, code writing, document analysis, and more.

Versions and Evolution

Version	Release period
Claude 1 (initial)	Early 2023	Basic release.
Claude 2	July 2023	Improved performance and response length.
Claude 3 family (Opus, Sonnet, Haiku)	2024	Model lineup by performance and speed. More diversified by use case.
Claude 4 family (for example, Opus 4, Sonnet 4.5)	2025	Strong for advanced tasks such as code generation.

Features and Advantages

Designed to perform many tasks such as natural language conversation, code generation, data analysis, and image input processing.
Recent versions have a much larger context window, making them stronger at handling long context and solving complex problems. For example, Claude Sonnet 4.5 improved input/output token pricing and context window characteristics.
Practical use is also considered, including APIs for developers and enterprise customers, agent usage, and tool integration.

Main Features

Focus on safety and transparency
- Focuses on avoiding harmful answers and providing reasonable, explainable responses.
Long context processing
- The Claude 3 series can understand up to 200,000 tokens, about 150-200 pages, making it strong for analyzing long documents.
Intuitive conversation
- It has strong language ability in naturally understanding the user’s intent and nuance.
Enterprise API support
- Supports workflow automation and document processing through integrations with Slack, Notion, Zapier, and more.

Differences from ChatGPT

Category	ChatGPT (OpenAI)	Claude (Anthropic)
Developer	OpenAI	Anthropic
Representative models	GPT-4, GPT-5	Claude 3 series
Philosophy	Efficiency and accuracy focused	Safety and human-centered design
Strengths	Code writing, many integrations	Document understanding, ethical control
Context length	About 128k tokens (GPT-4 Turbo)	About 200k tokens (Claude 3)

Use Cases

Companies use it for coding automation, document summarization, data analysis, chatbot responses, and more. It is also mentioned for code refactoring and bug fixing.
General users can also have natural conversations through web and mobile chat interfaces.
It is preparing to enter the Korean market, and cooperation with Korean companies and policy organizations is also underway.

Limitations and Notes

It is not yet a “complete artificial intelligence” (AGI) or a self-aware system, and errors or false information (“hallucinations”) may occur. For example, cases have been reported where a model generated incorrect legal citations.
For corporate or organizational use, licensing, data security, and regulatory compliance are important.
Safety and ethical considerations are required from companies and developers, and access restrictions for companies in certain countries are also being discussed.

Notes for Korean Users

Korean input and output are possible, but response quality may be somewhat lower than in native-language environments such as English, so review is needed for important work.
Although entry into the Korean market is planned, a domestic specialized version or full localization may not yet be complete.
Depending on the purpose of use, it may be divided into free or paid plans, and APIs may incur costs.

Why AI Models Use GPUs

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

AI models, especially deep learning models, must perform enormous amounts of computation to train on and infer from massive data. Since using only CPUs is too slow and inefficient for this work, GPUs specialized for large-scale parallel computation are essential.

What Is a GPU?

A GPU (Graphics Processing Unit) was originally designed to quickly perform graphics operations, such as pixel rendering and 3D graphics processing.
The reason graphics in games and videos can appear smooth without stuttering is also the GPU’s fast parallel computation.

CPU vs GPU Structure Comparison

Category	CPU	GPU
Number of cores	A few high-performance cores (4-32)	Thousands to tens of thousands of small cores
Processing method	Sequential processing	Parallel processing
Strengths	General logic processing, complex branch handling	Large volumes of simple repetitive operations, matrix/vector operations
Suitability for AI	Low	Very high

The matrix multiplication and vector operations required for deep learning training fit perfectly with the GPU’s parallel processing method.

Why GPUs Are Essential for AI

Parallel Computing Ability

Deep learning models must simultaneously calculate many parameters and connections between neurons.
GPUs process these all at once in parallel, dramatically improving speed.

Matrix/Vector Operation Optimization

Neural networks are made up of many matrix and vector multiplications.
Example: y = Wx + b (weight matrix x input vector + bias)
GPUs were originally optimized for matrix operations for graphics processing, such as pixel calculation and 3D rendering, so they fit AI computation well.

Shorter Training Time

During model training, millions to billions of parameters must be updated.
Training that would take weeks or months using only CPUs can be reduced to hours or days with GPUs.

Large-Scale Data Processing

AI handles high-dimensional data such as images, speech, and text.
GPUs can process large batches of data simultaneously, making training and inference faster.

Stronger Inference Performance

GPUs provide fast responses not only for training but also for real-time services, such as chatbot responses, image/speech recognition, and autonomous driving sensor data analysis.

Ecosystem Support

Representative deep learning frameworks such as PyTorch and TensorFlow are optimized for GPUs based on CUDA, NVIDIA’s library.
When using GPUs, optimized kernels can be used automatically, providing additional performance gains.

Relationship Between GPUs and AI

Early AI researchers realized that CPUs alone had limitations when training on large amounts of data. They applied graphics-processing GPUs to deep learning training, and the parallel computation structure matched AI perfectly. Since then, AI and GPUs have become inseparable, and most AI research and services today are built on GPU-based systems.

AI-Specific Hardware Beyond GPUs

Recently, AI-specialized chips other than GPUs have also been developed and used.

TPU (Tensor Processing Unit): Developed by Google and optimized for tensor operations
NPU (Neural Processing Unit): For mobile devices and optimized for energy efficiency
FPGA, ASIC: Custom chips specialized for specific AI operations

However, GPUs are still the most widely used in terms of versatility, performance, and ecosystem.

Summary

CPU = strong at sequential processing (general-purpose processor)
GPU = specialized for parallel computation (optimized for AI and deep learning)
The reason AI models use GPUs = to process large-scale matrix/vector operations quickly and simultaneously

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.

Understanding and Using Artificial Intelligence

kc@example.com (kc kim) — Sat, 16 Aug 2025 22:33:00 +0900

Introduction

Artificial intelligence (AI) is no longer a technology of the future. It is now a core technology deeply embedded in everyday life. This section systematically explains AI from its basic concepts to its latest applications, helping readers understand the nature of AI and use it in practice.

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

What Is OpenAI Codex?

kc@example.com (kc kim) — Sun, 26 Apr 2026 15:49:00 +0900

What Is Codex?

Codex is an AI-based software engineering agent developed by OpenAI.
It is different from ChatGPT because it is not simply a tool that “helps with code,” but AI that actually performs tasks on your behalf.

One-Line Definition

“An AI developer that performs development work when you delegate it”

ChatGPT -> A tool that helps you think
Codex -> An agent that handles the work for you

This difference is the core point.

Difference Between ChatGPT and Codex

Category	ChatGPT	Codex
Role	Questions, explanations, ideas	Performs actual work
Output	Text answers	Code + execution results
Scope	Focused on a single response	File/project-level work
Method	Conversational	Task delegation

Simply put:

ChatGPT: “This is how you can do it”
Codex: “I tried it directly (including the code)”

Core Features of Codex

Performs Real Code Work

Codex directly performs tasks such as:

Feature implementation
Bug fixes
Refactoring
Writing test code
Creating pull requests

Its key feature is that it does not merely generate content, but completes the work through to the end.

Project-Level Understanding

Reads and analyzes the entire codebase
Understands relationships among modules
Tracks data flow

In other words, it works based on the “entire service,” not just “one file.”

Independent Execution Environment (Sandbox)

For each task, Codex repeats steps such as:

Creating an independent execution environment
Modifying code
Running tests
Verifying results

It can also follow a structure that repeatedly runs until tests pass.

Parallel Work (Multitasking)

Performs multiple tasks at the same time
Continues working in the background

Examples:

Developing feature A
Fixing bug B
Adding test C

It can process human development tasks in parallel.

Automation Agent

Codex can handle not only simple requests but also tasks such as:

CI/CD work
Issue organization
Log analysis
Repetitive work processing

Practical Use Examples

Development Work

“Add caching to this API”
“Refactor this code and add tests”

-> Code modification + test execution + result reporting

Test Automation

Configuring a Testcontainers environment
Generating Kotest/JUnit tests

It is especially powerful for Spring-based development like yours.

Maintenance

Analyzing old code
Replacing deprecated APIs
Improving performance

Productivity Automation

Document generation
Release note writing
Code review assistance

Advantages from a Developer’s Perspective

Maximized development speed

Eliminates repetitive work
Automates through actual implementation

Context retention

Works based on understanding the whole project

Maintains focus

Enables delegation of “annoying tasks”

As a result, development can continue while maintaining a flow state.

Limitations (Important)

Not perfect

May make poor design decisions
May generate inefficient code

Responsibility

Humans must ultimately verify the result

Context limits

Difficult to fully understand organizational policies and business logic

Recent Trend (Important Point)

Recently, Codex has moved beyond a simple coding tool:

Expanding into a work automation agent, not just development
Being applied to real work in many companies
Used by millions of developers

The shift is from “the era when AI answers” to “the era when AI works” ([Reuters][4]).

Conclusion

Codex is changing the existing development workflow as follows.

Direct implementation -> task delegation
Single task -> parallel work
Code writing -> result-centered development

Key Summary

ChatGPT helps you think, and Codex does the work for you.

How to Install and Use OpenAI Codex

kc@example.com (kc kim) — Sun, 26 Apr 2026 15:49:00 +0900

From a developer’s perspective, the important point is that Codex is not so much an “installable program” as a tool you connect to and use in several ways.

In other words, it is not a structure that must always be installed locally. It can be used through many interfaces such as ChatGPT, CLI, IDE, and the web.

Installing Codex

Using It in ChatGPT (Easiest Method)

In fact, most people start without a separate installation.

Method

Log in to ChatGPT
Enable the Codex feature (plan required)
Start using it immediately

Codex is provided as part of ChatGPT plans.

Features

No installation
Immediate use
Simplest method

Installing the CLI on Mac (Recommended for Developers)

If you want to use Codex from a terminal-based Mac environment, this is the key method.

Prerequisites

First, check the basic environment.

The following are required:

macOS (Ventura or later recommended)
Node.js (18 or later)
npm or pnpm

Installing Node (if not already installed)

brew install node

Check installation:

node -v
npm -v

Installing Codex CLI

This is the officially provided CLI installation method.

npm install -g @openai/codex

Check installation:

codex --version

codex

On first execution, the console screen appears as follows.

  Welcome to Codex, OpenAI's command-line coding agent

  Sign in with ChatGPT to use Codex as part of your paid plan
  or connect an API key for usage-based billing

> 1. Sign in with ChatGPT
     Usage included with Plus, Pro, Business, and Enterprise plans

  2. Sign in with Device Code
     Sign in from another device with a one-time code

  3. Provide your own API key
     Pay for what you use

  Press Enter to continue

Select option 1 to log in with your ChatGPT account, and the browser will open.

After logging in, the CLI and your account are connected.

Next, check the content shown in the console and press the required buttons a few times. Then you are finally ready to use it.

╭───────────────────────────────────────────────╮
│ >_ OpenAI Codex (v0.125.0)                    │
│                                               │
│ model:     gpt-5.5   /model to change         │
│ directory: ~/develop/devkuma/devkuma-hugo-www │
╰───────────────────────────────────────────────╯

  Tip: GPT-5.5 is now available in Codex. It's our strongest agentic coding model yet, built to reason through large codebases, check
  assumptions with tools, and keep going until the work is done.

  Learn more: https://openai.com/index/introducing-gpt-5-5/


› Use /skills to list available skills

Usage Flow

To summarize, the usage flow is as follows.

Run codex in the CLI
Proceed with login using your ChatGPT account
Run it from the project folder
Give tasks in natural language

After this process, the CLI and account are connected.

Example:

"Add Redis caching to this project"

IDE Extension (VS Code, etc.)

How to Use

Open VS Code
Install the Codex extension
Log in

Advantages

Make changes while viewing code
Automatic refactoring
Code review support

Web/App-Based Use

Codex also supports the following methods:

Codex web
Dedicated Codex app
GitHub integration

GitHub connection is especially required on the web.

Using Codex

API/SDK Method (Advanced)

If you want to use it directly from the backend:

Use an OpenAI API key
Call a Codex model
Build an automation system

Recommended Installation and Use by Developer Level

Realistically, it can be divided as follows:

Beginner
- ChatGPT -> use immediately
Practical work
- Use CLI and IDE together
Advanced
- API + automation (CI/CD integration)

Summary

Important Point (Often Confused)

“Installing Codex = downloading a program” is not accurate. More precisely, it means “installing an interface that lets you use Codex.”

Developer Tips

This combination is efficient:

CLI: Large tasks such as refactoring and feature additions
ChatGPT: Ideas and design
IDE: Detailed edits

The key is to use them together.

One-Line Summary

Codex is not a tool you install; it is an AI development agent you connect to and use

Google AI

kc@example.com (kc kim) — Sun, 26 Apr 2026 11:48:00 +0900

An introduction to Google AI tools

AI Terms

kc@example.com (kc kim) — Sat, 16 Aug 2025 22:33:00 +0900

Recent AI Terms That Can Be Confusing and Difficult

AI (Artificial Intelligence)
- Technology that enables computers to imitate human intelligence, learn, and solve problems
ML (Machine Learning)
- Technology that enables AI to learn automatically from data and make predictions
DL (Deep Learning)
- A type of ML that uses artificial neural networks to learn complex patterns
AX (AI Transformation)
- Organizational transformation centered on AI, going beyond DX
AGI (Artificial General Intelligence)
- Artificial intelligence that is not limited to specific tasks and can solve problems intelligently across multiple fields like a human
Gen (Generative) AI
- Artificial intelligence that generates text, images, music, video, and more
Prompting
- The method of asking questions so that Gen AI can produce the needed answer
LLM (Large Language Model)
- Technology that understands and generates language-like text based on big data
FM (Foundation Model)
- A model pre-trained on large and diverse datasets, used as a base model for language processing, image recognition, audio/video generation, and more
Hallucination
- A phenomenon in which AI reaches an incorrect conclusion and generates output or content that does not exist in reality

Skipping Claude Code Permission Prompts

kc@example.com (kc kim) — Thu, 11 Apr 2024 12:18:00 +0900

When using Claude Code, if you do not want it to ask for permission every time it modifies files or runs commands, you can run it in “YOLO mode (allow all)” with the --dangerously-skip-permissions flag, or configure detailed permissions through settings.json.

1. Always Run Without Permission Prompts (YOLO Mode)

If you run the following command in the terminal, file creation, deletion, and command execution proceed immediately without asking for approval.

Linux/macOS

Add alias claude='claude --dangerously-skip-permissions' to .bashrc or .zshrc for a permanent setting.

Windows

Set a doskey macro with claude=claude --dangerously-skip-permissions $*.

2. Allow Only Specific Tools (Settings File)

As a safer method than --dangerously-skip-permissions, you can specify allowed tools such as Bash and file read/write in .claude/settings.json.

Example:

{"permissions": {"allow": ["Bash(find:*)"]}}

3. Auto Approval Mode (Auto Mode)

In recent versions, you can use “Auto mode,” which operates without approval popups while maintaining certain safeguards. This can be controlled in environment settings.

Note:
--dangerously-skip-permissions speeds up work, but because it can also execute dangerous actions without restriction, it is recommended only for automation or experimental environments.

Claude

kc@example.com (kc kim) — Sun, 26 Apr 2026 11:48:00 +0900

An introduction to Claude

AI Tools

kc@example.com (kc kim) — Sat, 16 Aug 2025 22:33:00 +0900

AI tools

OpenAI Skills Explained, Installation, and Usage

kc@example.com (kc kim) — Fri, 01 May 2026 10:00:00 +0900

What Are Skills?

When using AI tools, there will inevitably be moments when you repeatedly enter the same prompt. Asking for code reviews, generating test code, and analyzing logs are all tasks where explaining the same thing every time is less efficient than it seems.

The key to solving this problem is “Skills.” Simply put, a Skill is a feature that turns frequently used work into a single reusable command.

Once created well, you can get the same result with a short trigger instead of explaining it at length every time.

In other words, Skills are a format for writing reusable workflows, and they can be used not only in Codex CLI but also in IDE extensions and the Codex app.

Core Structure

A Skill may look complex, but the structure is simple. The core is the flow of “input -> processing -> output.”

Input: User request, such as “make tests for this code”
Processing: Defined prompt logic
Output: Result, such as test code or an explanation

The important point is that a Skill does not simply save a prompt. It also includes the role, rules, and output format.

For example, the difference between a simple request and a Skill is as follows.

General request:

“Make test code for this code”

Skill:

Role: Test code expert
Rules: Use Kotest and consider WebFlux
Output: Immediately executable code

This one difference can completely change the quality of the result.

Installing Skills

Skills can be installed easily with commands or by directly placing files.

Method 1: Install from the Official Catalog

The official OpenAI Codex skill catalog is a folder-structured module that bundles instructions, scripts, and resources so AI agents can repeatedly perform specific tasks.

You can find the Codex skill catalog in the official GitHub repository, openai/skills.

https://github.com/openai/skills

To install a Skill in Codex, run $skill-installer.

$skill-installer {skill-name}

For example, to install a skill named screenshot, run:

$skill-installer screenshot

When executed, files such as the Markdown specification (SKILL.md) are created under ~/.codex/skills/.

The following files are created when the screenshot Skill is installed.

.codex
└── skills
    └── screenshot
        ├── agents
        │   └── openai.yaml
        ├── assets
        │   ├── screenshot-small.svg
        │   └── screenshot.png
        ├── LICENSE.txt
        ├── scripts
        │   ├── ensure_macos_permissions.sh
        │   ├── macos_display_info.swift
        │   ├── macos_permissions.swift
        │   ├── macos_window_info.swift
        │   ├── take_screenshot.ps1
        │   └── take_screenshot.py
        └── SKILL.md

After installation, restart Codex and it can be used immediately.

Method 2: Install by Entering a GitHub URL

You can also install by entering a GitHub URL directly.

$skill-installer https://github.com/openai/skills/tree/main/skills/.curated/{skill-name}

Method 3: Add Directly to the Project Root

Create a .agents/skills/ folder at the project root and place the skill folder there. If this is pushed to Git, all team members can use it immediately.

Using Skills in Codex

Codex can use skills in two ways.

Explicit Invocation

In the CLI or IDE, you can explicitly call a skill by entering ${skill-name} in the prompt.

For example, to use the screenshot skill:

$screenshot https://www.devkuma.com --fullpage

Alternatively, use the /skills command to view and select from the list of available skills.

Implicit Invocation

If you describe the task, Codex automatically finds and runs a suitable skill.

For example, if you say “Apply the comments on this PR,” the gh-address-comments skill is automatically executed.

If the task matches a skill’s description, Codex automatically selects it.

Implicit matching depends on the description in the skills/SKILL.md file.

Basic Skill File Structure

Codex first refers only to each skill’s name, description, and file path. It loads the full contents of SKILL.md only when it decides to use that skill.

Codex includes a list of available skills in the initial context so it can select the right skill. This list is limited so it does not take up too much prompt space, roughly 2% of the full context or up to 8,000 characters. If there are many skills, descriptions are shortened first. If there are too many, some skills are excluded from the list and a warning is shown.

This limit applies only to the initial skill list. Once Codex selects a specific skill, it reads the full SKILL.md.

A skill is a directory made up of a SKILL.md file plus optional scripts and resources.

my-skill/
├── SKILL.md        # Required: instructions + metadata
├── scripts/        # Optional: executable code
├── references/     # Optional: documents
├── assets/         # Optional: templates, resources
└── agents/
    └── openai.yaml # Optional: UI and dependency settings

SKILL.md
- Required file containing name, description, and the core procedure Codex should follow.
scripts/
- Optional, used when the same code would otherwise be written repeatedly.
- Good examples include collecting changed files, organizing PR metadata, or running a specific test.
references/
- Optional place for reference materials.
- Good examples include RLS policy check criteria, a team’s API contract, or deployment policy.
assets/
- Optional place for templates or resources used in outputs.
- Examples include review comment templates, PR description templates, and report format files.

Creating a Skill

Official skills alone may not be enough. You may need custom skills for your own or your team’s workflow.

To create a custom skill, you need to create the SKILL.md file described above.

How to write SKILL.md:

---
name: skill-name
description: Clearly explain when this skill should and should not run
---

Write the skill instructions Codex should follow

The description is the most important part. Since implicit matching depends on this description, it must be clear and concise.

Put core use cases near the beginning
Write trigger keywords clearly
Make it matchable even if the description is shortened
Include both Korean and English keywords
List expressions that users are likely to enter
Also state what the skill does not do to prevent incorrect matching

Description example:

description: "Automatically applies PR review comments. Reacts to '리뷰 반영', 'PR 코멘트', 'address comments', 'fix review'. Does not perform the code review itself."

Create with the Basic Generator

You can write SKILL.md directly, but using the basic generator is recommended.

$skill-creator

The generator asks:

What the skill does
When it should run
Whether to include scripts; the default is instruction-only

Codex automatically detects skill changes. If changes are not reflected, restart Codex.

Skill Storage Locations

Codex loads Skills from several locations.

Scope	Location	Purpose
REPO	`$CWD/.agents/skills`	Skills apply only to the current working directory
REPO	`$CWD/../.agents/skills`	Skills that apply only to the parent directory
REPO	`$REPO_ROOT/.agents/skills`	Shared skills for the whole repository
USER	`$HOME/.agents/skills`	Personal user skills applied to all my projects
ADMIN	`/etc/codex/skills`	System-wide shared skills
SYSTEM	Built into Codex	Built-in default skills such as `$skill-installer` and `$skill-creator`

Codex also supports symlinked skill folders.

These locations are for local development and exploration. If you want external distribution, it is better to use a plugin.

Optional Metadata

If you add agents/openai.yaml, you can configure UI and policy settings.

interface:
  display_name: "Name shown to users"
  short_description: "Short description"
  icon_small: "./assets/small-logo.svg"
  icon_large: "./assets/large-logo.png"
  brand_color: "#3B82F6"
  default_prompt: "Default prompt"

policy:
  allow_implicit_invocation: false

dependencies:
  tools:
    - type: "mcp"
      value: "openaiDeveloperDocs"
      description: "OpenAI Docs MCP server"
      transport: "streamable_http"
      url: "https://developers.openai.com/mcp"

Default value of allow_implicit_invocation: true
If set to false, automatic invocation is disabled, while explicit invocation remains possible.

Enabling and Disabling Skills

If there is a skill you do not want, you can disable it in ~/.codex/config.toml instead of deleting it.

[[skills.config]]
path = "/path/to/skill/SKILL.md"
enabled = false

Restart Codex after changing the setting.

Distributing Skills as Plugins

Local skill folders are suitable for development and testing.

Packaging as a plugin is useful in cases such as:

Distributing reusable skills
Bundling multiple skills together
Including app integrations

A plugin can include:

Multiple skills
App mappings
MCP server settings
UI assets

Using Claude Skills in Codex

Because both Claude and Codex tools follow the same Agent Skills open standard (agentskills.io), they use the same SKILL.md format, and Anthropic’s Skills repository can also be used in Codex.

The method is simple:

Clone the Claude Skills repository into .agents/skills/.
Add a list-skills script.
- It reads SKILL.md files in the skills folder and outputs JSON.
Add an instruction to AGENTS.md: “Run list-skills to check available skills.”

This allows skills made for Claude Code to be used in Codex as they are. However, this is a usage method discovered by the community, and it is not an officially supported interoperability feature from OpenAI or Anthropic.

Basic skills can be mutually compatible. However, each tool’s extensions, such as Claude Code’s allowed-tools and Codex’s .system directory, may not be compatible.

Claude Code Skills vs Codex Skills

	Claude Code	Codex
Definition file	`SKILL.md`	`SKILL.md`
Installation method	`/plugin install + manual copy`	`$skill-installer`
Official catalog	Available	35+ curated
Implicit invocation	Supported	Supported
Team sharing	Git commit	Git commit
Execution environment	CLI + IDE extension	CLI + app + IDE

Practical Productivity Uses

Skills can be used in Codex CLI, IDE extensions, and the Codex app.

What matters more than simply creating them is where they are used. Here are a few cases where the effect was significant.

Automated log analysis
- WebFlux logs are difficult to analyze because of asynchronous flow. If you create a Skill as a “log interpretation expert,” it can explain complex logs structurally.
Standardized test code
- Skills can solve the problem of each team having a different test style. If rules are enforced, all code is generated in the same style.
Removing repetitive work
- API documentation generation
- Error message analysis
- Code refactoring suggestions

If these tasks are turned into Skills, they can be handled almost at an automation level.

The key is to set a rule: “Always create a Skill for tasks you do often.”

Summary: Codex Skills Are a Core Tool for Developer Productivity

Codex Skills are not just a prompt-saving feature. They are a powerful tool for automating repetitive work and standardizing output quality.

At first, creating just one is enough. Start with the task you do most often, such as test code generation, log analysis, or code review.

Once you get used to them, the development flow changes enough to make you wonder why you did not use them earlier.

FAQ

Q1. When is it good to use Codex Skills?

If you make the same request more than three times repeatedly, it is better to turn it into a Skill immediately. It is especially effective for tasks such as test code generation, documentation, and log analysis.

Q2. If there are many Skills, does management become difficult?

That is why naming and purpose definition are important. Clear names such as “test-webflux” and “log-analyzer” make management easier.

Q3. Can beginners use them right away?

Yes. You only need to clearly define Role, Rules, and Output without complex logic. In fact, Skills can be especially helpful for beginners because they reduce repetitive work.

NotebookLM

kc@example.com (kc kim) — Mon, 23 Feb 2026 08:48:00 +0900

What Is NotebookLM?

NotebookLM is an AI-based research and note organization tool developed by Google. Based on materials uploaded by the user, such as documents, PDFs, and web links, AI understands the content and performs summarization, organization, and question answering. It is close to a personalized AI research assistant.

Unlike conventional chatbots that answer based on general knowledge, its core feature is that it finds evidence and answers only within the materials provided by the user.

Google NotebookLM

Main Features

Grounded AI Answers

Generates answers only from uploaded documents
Provides sources/citations with answers
Strong for analyzing papers, contracts, and lecture materials

Automatic Summarization

Summarizes long PDFs around key points
Structures key concepts, arguments, and conclusions
Can be used to draft blogs and reports

Questions and Deeper Analysis

Examples:

“What are the three core arguments of this document?”
“What assumptions does the author make?”
“Analyze it critically”

-> Beyond simple summaries, critical analysis and comparative analysis are also possible

Audio Overview

A feature where two AIs explain the document content as if having a conversation -> Can be listened to like a podcast

Supported Formats

Google Docs
PDF
Website links
Text files
Google Slides

Differences from ChatGPT

Category	NotebookLM	ChatGPT
Answer basis	Focused on uploaded materials	Based on general training data
Source display	Provided	Not provided by default
Research analysis	Very strong	Possible, but general-purpose
Creative writing	Average	Very strong

Recommended For

People who do a lot of paper or research work
People preparing to write blogs or books
Office workers who need to analyze contracts or policy documents
Students who need summaries for exam preparation

Summary

NotebookLM is not a simple AI chatbot. It is closer to “an AI research partner that reads and understands my materials.”

It can be especially powerful when writing a book, such as a Kotest book project, or creating material-based content.

AI Q&A

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

This section collects questions and answers about AI.

Ollama

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

What Is Ollama?

Ollama is a tool widely used recently among AI and LLM developers.

Ollama is an open source platform that makes it easy to run and manage large language models (LLMs) in a local environment.
In other words, without using a cloud model such as the OpenAI API, it lets you load and use models such as Llama, Mistral, Gemma, and CodeLlama on your own PC (Mac/Linux/Windows).

Main Features of Ollama

Local execution support
- Models can run even without an internet connection
- Useful for corporate security and personal privacy
Simple model deployment
- Run a model with a single command such as ollama run llama3
- Supports model package management like Docker, managed with a configuration file called Modelfile
Support for multiple models
- Can download and run many models such as Meta LLaMA, Mistral, Gemma, Code Llama, and Phi
API support
- Opens a local server in REST API format (http://localhost:11434/api/generate) so other apps can call it
- Can be used like a local OpenAI API server
GPU optimization
- Supports MPS (Mac) and CUDA (NVIDIA GPU), making it fast
- Can also run on CPU, but more slowly

Using Ollama

Installation

Packages are provided for macOS, Linux, and Windows
- https://ollama.com/download
macOS
- brew install ollama

After installation on macOS, running Ollama displays an Ollama icon in the menu bar.

Running a Model

ollama run llama3

On first execution, the model is automatically downloaded and then run. The llama3 model is 4.7 GB.

Downloading Models

Search for models on the official site and install the model you want to use.

Recommended models
- https://www.ollama.com/library/gpt-oss
  - Use this if you want ChatGPT-level chat, analysis, or work support. It is a little slow on a MacBook, but works well.
- https://www.ollama.com/library/phi4-mini
  - Suitable for simple tasks such as searching for targets to call from an MCP server. Any lightweight model that supports tools is fine. Do not use qwen or deepseek.

API Call (for example, curl)

curl http://localhost:11434/api/generate -d '{
  "model": "llama3",
  "prompt": "Explain quantum computing in simple terms"
}'

Model Management

ollama list -> Check installed models
ollama pull mistral -> Download a new model
ollama create mymodel -f Modelfile -> Create a custom model

Comparing Ollama with Other LLM Execution Frameworks

Tool	Features
Ollama	Simplest installation and execution, local API support, model package management
LM Studio	GUI-based, intuitive model selection and execution
vLLM	Optimized for high-performance server execution, mainly used for large-scale deployments
Text Generation WebUI	Runs various models and provides a Web UI
OpenAI API	Cloud-based and can use the latest models, but has cost and privacy issues

Use Cases

Building a local AI assistant in a development environment
Building an internal chatbot connected to secure company data
Building RAG systems by integrating with frameworks such as LangChain and LlamaIndex
Prototyping: Experimenting quickly without using OpenAI API costs

Summary

Ollama is a platform like “Docker for LLMs” that makes it easy to run LLMs locally. It can be used for many purposes, from personal research to enterprise chatbots.

The Concept and History of Artificial Intelligence

kc@example.com (kc kim) — Sat, 16 Aug 2025 22:33:00 +0900

Definition of Artificial Intelligence

Artificial intelligence refers to technology that enables computers to perform human abilities such as learning, reasoning, and problem solving. It began with simple rule-based automation and has now evolved into machine learning and deep learning technologies that can learn and adapt on their own.

Example: Smartphone voice assistants such as Siri and Google Assistant go beyond executing simple commands and increasingly support sophisticated conversations by learning users’ language patterns.

History of Artificial Intelligence

1950s: Alan Turing proposes the “Turing Test”
1960s-1970s: Rule-based expert systems emerge
1980s-1990s: Neural network research resumes and machine learning advances
2000s onward: Deep learning grows rapidly with the development of big data and GPUs
Today: AI spreads into many fields, including natural language processing, autonomous driving, and medical diagnosis

Chart 1: Timeline of artificial intelligence history (major technological developments by year)
Image source: https://spri.kr/posts/view/21643?code=industry_trend

GitHub Copilot

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

What Is Copilot?

GitHub Copilot is an AI-based code completion tool jointly developed by GitHub and OpenAI.
When a developer writes code, it analyzes comments, function signatures, and context to automatically suggest the most appropriate code.
It is often called an AI pair programmer.

Main Features

Automatic code suggestions
- Automatically generates a line, an entire function, or even test code
- Quickly fills in repeated patterns
Comment-based development
- Generates code when natural language comments such as // Write a function that adds two numbers are entered
Context understanding
- Can make more natural suggestions by referring to the current file and other files in the project
Support for many languages and frameworks
- Supports a wide range of languages, including Python, JavaScript, TypeScript, Go, Java, C#, and C++
IDE integration
- Provided as plugins for major development environments such as VS Code, JetBrains IDEs, and Neovim

Use Cases

Reducing repetitive work: Writing boilerplate code, CRUD APIs, and test code
Learning new languages: Quickly learning unfamiliar language or framework syntax
Algorithm implementation: Writing requirements as comments and generating code automatically
Refactoring support: Suggesting better implementation methods

Advantages

Faster development: Greatly reduces routine repetitive coding
Learning effect: Shows examples of unfamiliar APIs or syntax
Code consistency: Automates boilerplate according to team rules
Test writing support: Accelerates the TDD cycle

Limitations and Drawbacks

Imperfect accuracy: It does not always produce correct or optimal code
Security risks: May include vulnerabilities, such as missing SQL injection defenses
License issues: Because it was trained on public code, some generated code may raise copyright issues
Context limits: It has limits in deeply understanding an entire project

Cost

Paid subscription (as of 2025)
- Individual: about $10 USD/month
- Business: about $19 USD/month per user
Free for students and open source contributors

Difference Between Copilot and Vibe Coding

Copilot: The developer leads, and AI suggests as an assistant tool
Vibe coding: AI leads, and the developer provides only goals and feedback as a creative style

Similar AI Coding Tools

Amazon CodeWhisperer (AWS)
Tabnine
Cursor IDE (IDE with ChatGPT built in)
Replit Ghostwriter

Summary

GitHub Copilot is an “AI pair programmer” that provides real-time code suggestions based on comments and code context.
It reduces repetitive, low-productivity work and helps create draft code quickly, but verification, review, and testing are always required.

Core Technologies of Artificial Intelligence

kc@example.com (kc kim) — Sat, 16 Aug 2025 22:33:00 +0900

Machine Learning

Machine learning (ML) is a technology that allows computers to learn patterns from data and make predictions or decisions without being explicitly programmed. In other words, it is the ability to discover rules and relationships from data without a person having to write every rule manually. Representative types include supervised learning, unsupervised learning, and reinforcement learning.

Types of Machine Learning

Machine learning is mainly divided into three types according to the learning method.

Supervised Learning
- Definition: Trains a model by providing input data together with the corresponding correct answers, or labels.
- Purpose: Predict correct answers from input data
- Examples:
  - Email spam classification (spam/normal)
  - House price prediction (area, location -> price)
- Algorithms: Linear regression, logistic regression, decision trees, random forests, support vector machines, and others
Unsupervised Learning
- Definition: Learns from input data without correct answers to find hidden patterns or structures.
- Purpose: Data clustering and dimensionality reduction
- Examples:
  - Customer segmentation (clusters based on purchase patterns)
  - Anomaly detection (discovering fraudulent transactions)
- Algorithms: K-means clustering, hierarchical clustering, PCA (principal component analysis), and others
Reinforcement Learning
- Definition: Learns an optimal strategy using rewards and penalties that follow actions.
- Purpose: Optimize sequential decision making
- Examples:
  - AlphaGo playing Go
  - Route learning for autonomous vehicles
- Algorithms: Q-learning, deep Q-networks (DQN), policy gradient methods, and others

How Machine Learning Works

Data collection: Gather data for training (for example, images, text, sensor data)
Data preprocessing: Remove missing values, normalize data, and extract features
Model selection: Choose an ML algorithm suited to the problem type
Training: The model learns rules and patterns from data
Evaluation: Measure model accuracy with test data
Prediction: Predict results for new data

Real-World Examples of Machine Learning

Healthcare: Supporting disease diagnosis through MRI and CT image analysis
Finance: Predicting credit scores and detecting fraudulent transactions
E-commerce: Personalized product recommendations
Autonomous driving: Recognizing road objects and deciding routes
Natural language processing: Machine translation and chatbot dialogue generation

Advantages of Machine Learning

Enables data-driven decision making
Efficient for processing large-scale data and learning complex patterns
Performance can improve through repeated learning

Limitations of Machine Learning

Data dependence: High-quality data is essential
Overfitting: The model becomes specialized only for training data and lacks generalization ability
Lack of explainability: It can be difficult to understand why a model made a particular decision
Ethical issues: Biased data can produce unfair results

Deep Learning

Deep learning is a technology in the field of artificial intelligence that is based on artificial neural networks modeled after the structure of the human brain and learns complex patterns and features in data through multilayer structures. Compared with simple machine learning models that learn basic relationships in data, deep learning passes through many layers and learns increasingly abstract features, giving it strength in solving high-dimensional problems. It shows excellent performance in image recognition, speech recognition, natural language processing, and other areas.

Core Principles of Deep Learning

Artificial neural network structure
- Input layer: The layer where data first enters
- Hidden layer: The layer that processes input data and extracts features
- Output layer: The layer that outputs the final prediction or classification result
Learning process
- Forward Propagation: Calculates output values from input data
- Loss Function: Measures the difference between the output value and the actual value
- Backpropagation: Adjusts weights based on the error
- Gradually improves prediction accuracy through repeated learning
Activation Function
- Converts the output value at each node in the neural network to introduce nonlinearity
- Representative functions: Sigmoid, ReLU, hyperbolic tangent (Tanh)

Features of Deep Learning

Automatic feature extraction: Can learn useful features from data without humans defining them one by one
Multilayer structure: More hidden layers make it possible to learn more complex patterns
Suitable for large-scale data: Enables efficient learning through big data and GPU computation

Major Application Areas of Deep Learning

Image recognition

Road object recognition in autonomous vehicles, medical image diagnosis, and more

Speech recognition
- Voice assistants and real-time interpretation systems
Natural language processing
- Machine translation, chatbots, and document summarization
Recommendation systems
- Personalized product recommendations in e-commerce and video recommendation algorithms

Advantages of Deep Learning

Can achieve high accuracy even with complex, high-dimensional data
Reduces the burden of data preprocessing through automated feature extraction
Delivers far better performance than conventional methods in various fields

Limitations of Deep Learning

Requires large amounts of data for training: Performance drops when there is not enough data
Lack of explainability: The model’s decision process is opaque, creating a “black box” problem
Computational cost and time: Requires GPUs and large-scale computing resources
Risk of overfitting: May become optimized only for training data and lack generalization ability

Natural Language Processing (NLP)

Natural language processing (NLP) is a field of artificial intelligence technology that enables computers to understand, analyze, and generate the language humans use, namely natural language. Through NLP, machines can process language data in text and speech form, understand meaning, or generate appropriate responses. It has many applications, including translation, question answering, chatbots, and document summarization, and recent GPT-family models have achieved major results.

Main Goals of Natural Language Processing

Language Understanding
- Understand the meaning, context, and intent of input sentences
- Examples: Question answering systems and sentiment analysis
Language Generation
- Generate natural sentences that people can understand
- Examples: Chatbot conversations, automatic document summarization, and machine translation

Core Technologies of Natural Language Processing

Morphological Analysis
- Splits a sentence into morphemes, the smallest units of meaning
- Example: “나는 학교에 간다” -> [나/는, 학교/에, 가/ㄴ다]
Part-of-Speech Tagging
- Attaches parts of speech such as nouns, verbs, and adjectives to each word
- Provides a basis for analyzing sentence structure and meaning
Semantic Analysis
- Converts the meaning of sentences or words so a computer can understand them
- Example: Determining whether “bank” means a financial institution or the side of a river
Syntactic Parsing
- Analyzes the grammatical structure of a sentence to identify relationships among subject, object, and verb
Text Embedding
- Converts words, sentences, and documents into numerical vectors
- Allows machine learning models to process natural language data
Language Model
- Learns context and patterns to predict the next word
- GPT, BERT, and other modern models are representative examples

Applications of Natural Language Processing

Machine translation: Google Translate, DeepL, and others
Chatbots and conversational AI: Customer support automation and personal tutor AI
Text summarization: Automatic summarization of news articles, papers, and reports
Sentiment analysis: Positive and negative analysis based on social media and review data
Speech recognition and speech synthesis: Siri, Alexa, and TTS (Text-to-Speech) systems

Advantages of Natural Language Processing

Enables natural interaction between humans and machines
Makes it possible to automatically analyze and use massive amounts of text data
Improves services such as translation, search, and recommendation

Limitations of Natural Language Processing

Limits in context understanding: Difficulty understanding complex contexts or ambiguous expressions
Language and cultural bias: Bias can occur when relying on data from specific languages or cultures
Data dependence: Accuracy drops without high-quality training data
Need for computing resources: Training large language models requires enormous computational cost

Reinforcement Learning

Reinforcement learning is a technology that learns optimal action strategies based on rewards and penalties. AlphaGo’s victory in Go is a representative example.

Example: The match between AlphaGo and Lee Sedol was an event that showed the practical achievements of reinforcement learning to the world.

Reinforcement learning refers to an artificial intelligence technology in which an agent learns an optimal action strategy through experience while interacting with an environment. The agent observes the current state, chooses one of several possible actions, and receives a reward or penalty for that choice. Through this feedback, the agent gradually improves its policy so that it can obtain the maximum reward over the long term. The core of reinforcement learning is that the agent can discover an optimal strategy on its own through repeated trial and error, even without being explicitly told the correct answer. A representative example is AlphaGo. AlphaGo learned optimal moves in Go by repeating countless Go game simulations and reinforcement learning, and it achieved victory against the human champion Lee Sedol. This demonstrated that reinforcement learning can be effective even in solving complex problems.

GPT and Generative AI

kc@example.com (kc kim) — Sat, 16 Aug 2025 22:33:00 +0900

Concept of GPT

GPT (Generative Pre-trained Transformer) is an artificial intelligence model that learns massive language patterns through pre-training and can then generate new sentences.

Generative: Means that it can generate new sentences. It can produce answers to questions or create new text when asked to write.
Pre-trained: Means a model trained in advance on massive amounts of data. It learns language rules and expressions from various texts such as books, websites, and news.
Transformer: The name of a model architecture designed to understand and process sentence meaning effectively. This technology was developed by Google.

How It Works

Pre-training GPT learns patterns, grammar, meaning, and other aspects of language from massive text data available on the internet. For example, when given the sentence “The reason the sky is blue is,” it learns that descriptions such as “because sunlight is scattered” often follow.
Inference After pre-training is complete, GPT receives a question from a user and generates a suitable, natural answer.
Context Understanding GPT tries to respond appropriately by referring to previous context. For example, if “spring” was mentioned earlier in a conversation, it can more easily associate and use topics such as flowers or weather.

Advantages of GPT

Can perform many language tasks It can perform a range of language processing tasks, including question answering, writing, translation, summarization, and grammar correction.
Generates natural expressions GPT-based chatbots can produce conversational sentences naturally, providing an experience similar to talking with a person.
Fast responses It can generate and provide desired information within seconds.

Emergence of ChatGPT

ChatGPT is a conversational artificial intelligence service based on a large language model (LLM) developed by OpenAI. Based on GPT (Generative Pre-trained Transformer) technology, it conducts natural human-like conversations and supports various language processing tasks such as question answering, document writing, translation, and summarization. Its strengths include natural context understanding and multilingual support.

https://chatgpt.com/

Meaning of the Name

Chat: Refers to the conversational interface with users.
GPT: Refers to a pre-trained transformer architecture-based model with sentence generation ability.

It implies “a conversational service based on GPT technology.”

Features and Functions

Broad usability
- Supports question answering, sentence writing, translation, summarization, programming (code support), and more.
Natural conversational ability
- Can generate natural responses that feel like talking with a person.
Multilingual support
Can communicate in various languages, including Korean.
Technical flexibility
- Can generate output in various formats, including text, code, tables, and JSON, and can also be used in no-code environments.

Main Features

Can perform many language tasks
- It can be used broadly for question answering, writing, translation, summarization, grammar correction, code writing, and more.
Natural conversation generation
- Can produce natural language expressions that feel like human conversation.
Multilingual support
- Can communicate in many languages, including Korean.
Flexible output formats
- Can provide results not only as text but also in various formats such as code, tables, and JSON.

Technical Foundation

Pre-training: Learns the structure and meaning of language from massive text data such as the web, books, papers, and source code.
Transformer architecture: A core technology for context understanding and sentence generation that uses the self-attention mechanism to effectively identify relationships among words.

Use Cases

ChatGPT can be used in many ways and is being applied in practice across multiple industries and fields. Representative use cases include the following.

Customer service automation
- Corporate customer support departments use ChatGPT to provide 24-hour online consultation services. This makes it possible to handle basic customer inquiries quickly and helps human agents focus on complex issues.
Education and learning support
- In education, ChatGPT provides personalized learning suited to each student’s pace and level. When a student enters a question, AI provides an easy-to-understand answer and recommends additional learning materials, improving learning efficiency.
Programming code assistance
- Programmers can use ChatGPT to assist with coding and debugging. By automating repetitive coding tasks, function template generation, and error review, it improves development speed and productivity.
Content generation and summarization
- ChatGPT can perform various content generation tasks such as article summaries, advertising copy, and report writing. It can also summarize large documents and quickly deliver key information, improving information processing efficiency.

Limitations and Challenges

Although ChatGPT offers clear advantages, it also has the following limitations and challenges.

Possibility of factual errors

Because ChatGPT generates answers based on learned data, incorrect information or errors may sometimes be included. Therefore, additional verification is needed when using it for important decision making.

Limits in reflecting the latest information
- The model may not reflect the latest information or events after the point at which it was trained. In fields that require real-time information, it is appropriate to use it as an auxiliary tool.
- However, recent GPT models may compensate for this by integrating with internet search features.
Data use and copyright issues
- The data learned by ChatGPT may include copyrighted materials, and generated content may also be connected to intellectual property issues. Therefore, legal issues must be considered carefully in commercial use.
Prediction-based operation

GPT operates by probabilistically predicting the next position of a word. Therefore, it does not have deep understanding or emotions like a human; it is more accurate to view it as “predicting” patterns rather than truly “understanding” meaning.

LLM (Large Language Model)

kc@example.com (kc kim) — Sun, 24 Aug 2025 13:14:00 +0900

LLM Overview

LLMs (Large Language Models) are artificial intelligence models that learn from massive amounts of text data and can understand and generate natural language. They mainly use a deep learning-based transformer architecture, so they statistically capture the characteristics of human language and have advanced text generation and processing capabilities.

LLMs are now a central part of AI and play a very important role in language-based applications and system design.

How LLMs Work

Learning Method and Transformer Architecture

LLMs perform pre-training through unsupervised learning on hundreds of billions of text examples.
In particular, the transformer architecture understands contextual relationships through self-attention, and because it can process data in parallel compared with earlier recurrent neural networks (RNNs), it is highly efficient for training.

Parameters and Embeddings

The term “large” refers to the size of the parameters, which can range from billions to hundreds of billions. These enormous parameters make it possible to capture complex contexts and nuances in language. In addition, an “embedding” converts words into multidimensional vectors and numerically represents semantic similarity, helping the model understand context.

Application Areas

LLMs can be used very flexibly. Representative applications include:

Generative AI: Generates text such as essays, translations, and summaries based on user prompts
Code generation: Supports code writing from natural language, as seen in GitHub Copilot, AWS CodeWhisperer, and similar tools
Text classification and sentiment analysis: Customer feedback classification, document clustering, and more
Others: Knowledge-based question answering (KI-NLP), chatbots, customer service automation, and more

Types of Learning Methods

There are three main ways to use an LLM for a specific purpose:

Zero-shot learning: Performs various tasks with general prompts without additional training
Few-shot learning: Improves performance by providing a small number of examples
Fine-tuning: Further trains parameters on specific data to enable specialized use

Importance and Expected Benefits

Adopting LLMs can bring various benefits to companies and organizations:

Work automation: Improves productivity by automating language-based tasks such as customer support, document summarization, and content generation
Scalability and flexibility: A single model can flexibly handle multiple tasks such as translation, summarization, and question answering
Encouraging innovation: Provides a foundation for many future possibilities, including knowledge extraction, creative assistance, and conversational interfaces

Limitations and Considerations

When using LLMs, the following limitations should also be considered:

High resource requirements: Training and serving models with billions of parameters requires substantial computing resources.
Potential bias and errors: Limitations or biases in training data can be reflected in model outputs, requiring continuous improvement in accuracy.
Privacy and security concerns: Systems must prepare for possible relationships with private or sensitive data.

Summary

Item	Description
Definition	A massive text-based deep learning model capable of natural language understanding and generation
How it works	Transformer-based, with self-attention, embeddings, and billions of parameters
Applications	Text generation, code generation, classification, summarization, chatbots, and more
Learning methods	Zero-shot, few-shot, fine-tuning
Advantages	Automation, scalability, and creative use
Limitations	Resource demands, bias and accuracy issues, security risks, and more

MCP (Model Context Protocol)

kc@example.com (kc kim) — Sun, 24 Aug 2025 13:14:00 +0900

MCP Overview

Model Context Protocol (MCP) is an open standard protocol that helps AI, especially large language models (LLMs), interact effectively with external data sources and tools.

This protocol is designed so applications can deliver context to LLMs in a consistent way. In short, it is sometimes described with the metaphor of a USB-C port for AI. Just as USB-C connects many devices in a unified format, MCP connects AI models with many resources in a standardized way.

In other words, it is a common interface that allows AI models to connect with various external systems.

Main Features

Standardized interface
- Provides a common protocol that allows models to access “data sources / tools / applications.”
Pluggable structure
- It is not tied to a specific application. Any model that supports MCP can be extended in the same way.
Security and control
- Designed to limit the scope a model can access and allow access only to resources approved by the user.
Developer friendly
- Can be used commonly across several AI models such as OpenAI and Anthropic, so “an MCP tool built once can be used anywhere.”

Examples

When a model needs a “database query”:
```
Model -> MCP -> DB Adapter -> Database
```

When a model needs to “call a web API”:

Model -> MCP -> HTTP Adapter -> External REST API

In other words, MCP can be viewed as a foundational technology that standardizes the plugin ecosystem for AI.

Background and Need

AI models are essentially text-based in their input and output. However, real-world use requires many tasks such as DB lookups, API calls, and file input/output. Until now, individual solutions such as plugins, LangChain, and custom API bridges had to be used. MCP packages these into a standardized protocol.

Previously, for AI applications to interact with external systems, custom integrations were needed for each model and each tool. This greatly increased development and maintenance complexity, which was described as the M x N problem. MCP simplifies this into an M + N structure, helping AI applications connect with various tools in a standardized way.

Image source: https://www.descope.com/learn/post/mcp

Architecture and How It Works

Client-Server Structure

MCP adopts a client-server architecture.

An MCP client is an AI application, such as Claude Desktop.
An MCP server provides external resources such as file systems, databases, and APIs.

Communication Method

MCP exchanges requests and responses based on JSON-RPC 2.0, which improves interoperability through a standardized message exchange method. It also supports both local inter-process communication based on stdio and HTTP + SSE (Server-Sent Events)-based communication.

Role of the Server

An MCP server performs the following functions.

Tool Registry: Manages the list of available tools and functions
Authentication: Verifies access permissions
Request Handler: Handles client requests
Response Formatter: Processes results into a format the AI model can understand

An AI application can request the server’s “list of available tools” and then select and use an appropriate tool based on that list.

Developer Friendliness and Extensibility

Anthropic released MCP as an open source standard and provides SDKs for major languages such as Python, TypeScript, Java, Kotlin, and C#. This offers the advantage that client and server implementations are generally simple.

Effects and Benefits

Clear instructions: It is possible to clearly specify what data the LLM should handle
Removal of ambiguity: Multiple information sources can be clearly distinguished and referenced
Support for specialized processing: Dedicated processing for specific data formats is possible
Context examples: Various contexts such as file systems, databases, and cloud services can be used together

Thanks to these benefits, AI can expand its range of activity and provide more accurate, context-aware responses.

Adoption Timing and Ecosystem Trends

MCP was released as open source by Anthropic in November 2024, and adoption by developer communities and major AI tools increased rapidly from early 2025.
There are also mentions of the release of an official SDK for C#. Many MCP servers are currently operating, and security architecture and data protection have also become important concerns.

Summary Table

Item	Description
Definition	An open standard protocol that connects AI models with external data and tools
Background	Resolves the complexity of individual integrations and secures more flexible extensibility
Structure	Client-server structure, JSON-RPC, standardized message exchange
SDK	Provides Python, TS, Java, Kotlin, C#, and more
Benefits	Greater clarity, extensibility, automation, and security
Current trend	Growing rapidly since release, with expanding security and practical use

If you have more questions, feel free to ask. For example, I can also explain MCP server implementation examples or technical usage flows.

MCP Server

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

What Is an MCP Server?

An MCP server provides a standardized interface that connects an AI model so it can access external resources such as tools, data, and APIs.
Simply put, it is a server that provides a collection of tools AI can use.

Structure

MCP is broadly divided into clients and servers:

MCP client
- An application attached to an LLM environment, such as an IDE, chat UI, or notebook
- Receives the user’s prompt, runs the model, and sends requests to the MCP server when needed
MCP server
- Manages and provides multiple resources/tools/functions
- Communicates with clients through a standardized protocol based on JSON-RPC
- Examples: DB query server, file system server, API call server

What the Server Provides

An MCP server mainly provides four functions:

Resources
- Databases, files, documents, API responses, and more
- Examples: resource://db/customers, resource://filesystem/project/README.md
Tools
- Callable functions or actions
- Examples: searchCustomer(name), sendEmail(to, subject, body)
Prompts
- Provides predefined templates
- Example: “Prompt for generating SQL queries”
Events
- Delivers notifications or change events from the server in real time

Example Flow

A user enters in an IDE: “Search for customer ‘Hong Gil-dong’ in the DB”
The LLM decides it should call the “searchCustomer” tool through the MCP client
MCP client -> MCP server sends the request
The MCP server performs the actual DB lookup and returns the result
The LLM summarizes the result in user-friendly language and displays it

MCP Server Example

For example, a file system MCP server might provide:

Resource: Files in a project folder, such as /src/main.kt and /README.md
Tools: File reading, writing, and search functions such as readFile and writeFile
Prompts: Templates such as “Refactor this code”

When a server configured this way is connected, AI can directly explore and modify project files.

Analogy

MCP server = “hotel concierge”
- When a guest (LLM) asks, “Recommend tourist attractions,” the concierge handles multiple APIs and databases behind the scenes and provides organized information
MCP client = “hotel front desk”
- Talks directly with the guest, receives requests, and forwards them to the concierge

Summary

An MCP server acts as a backend that provides a standardized interface so an LLM can use external tools and data safely and consistently.

RAG (Retrieval-Augmented Generation)

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

RAG (Retrieval-Augmented Generation) Concept

RAG = Retrieval + Generation
An LLM (large language model) does not generate answers only from its internal knowledge. Instead, it retrieves relevant information from external databases such as documents, vector DBs, wikis, and company materials, then generates an answer based on those results.

In other words, it is not simply using “what the model knows,” but is like a smart assistant that “looks things up externally when needed and then answers.”

Why Is It Needed?

Overcoming the knowledge limits of LLMs
- LLMs do not know the latest information after the point when they were trained.
- For example, models like GPT do not know the latest information after their training point.
- With RAG, materials retrieved from a DB or the web can be used.
Reducing hallucinations
- LLMs sometimes make up things they do not know.
- Using external evidence can increase the reliability of answers.
- Instead of unsupported answers, responses can be based on actual documents or databases.
Using customized knowledge
- LLMs can use dedicated data such as internal company documents, reports, customer FAQs, papers, and codebases.
- Internal confidential documents can be used without training the model on them.

How RAG Works

Query input
- The user enters a question.
Retrieval stage
- The question is vectorized as an embedding, then related documents are retrieved from a vector database.
- Representative DBs: Pinecone, Weaviate, Milvus, FAISS, and others.
Generation stage
- The LLM generates an answer by referring to the retrieved documents and delivers it together.

In short, it has a “find -> refer -> answer” structure.

Example

Suppose a question comes in: “What was our company’s revenue in 2023?”

LLM alone: “Revenue in 2023 was 100 million dollars.” (No evidence, may be wrong)
Using RAG: Search internal financial reports -> retrieve related data -> “Our company’s revenue in 2023 was 920 billion KRW, an 8% increase from the previous year.” (Evidence-based answer)

Understanding Through an Analogy

LLM alone: A person with a good memory, but they may not know the latest information.
Using RAG: A person with a good memory answers while referring to a dictionary or search engine.

Comparing RAG and Fine-Tuning

Fine-tuning: Further trains the model itself, “internalizing” new knowledge
RAG: Leaves the model as is and retrieves external materials for use

Method	Advantages	Disadvantages
Fine-tuning	Fast and natural responses	Retraining is required whenever data is updated
RAG	Can always reflect up-to-date and customized information; quick to build	Answer quality depends on retrieval quality

In practice, RAG is often combined with some fine-tuning when needed.

Technology Stack Used to Implement RAG

Embedding models: OpenAI Embeddings, Sentence-BERT, and others
Vector DBs: Pinecone, Weaviate, Milvus, FAISS
LLMs: GPT, Claude, LLaMA, Gemini, and others
Frameworks: LangChain, LlamaIndex, Haystack

Summary

RAG is a method where an LLM uses a retrieval system together with the model to generate answers that are reliable and reflect up-to-date information.
In other words, it is a core technology for expanding knowledge and strengthening reliability.

AI Agent

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

What Is an AI Agent?

Unlike an LLM (large language model) that simply generates answers, an AI Agent is an intelligent system designed to interact with an environment and achieve a specific goal.
In other words, it is AI that judges for itself, uses necessary tools, takes action, and improves results.

Core Elements of an AI Agent

Goal
- The task the agent must perform, such as answering customer questions, writing reports, or modifying code.
Perception
- The stage of understanding the environment or input, such as user input, sensor data, or API responses.
Action
- Measures taken to achieve the goal, such as search, calculation, external API calls, or DB updates.
Feedback Loop
- The process of evaluating results and modifying the next action when needed.

Difference Between an AI Agent and a Simple LLM

LLM: Question -> answer (simple Q&A)
AI Agent: Question -> plan -> search/use tools -> execute multiple steps -> final answer

For example:

An LLM may answer “Tell me the weather in Seoul” based on past training data.
An AI Agent can call a real-time API and answer with the current temperature and weather.

Technologies Used by AI Agents

LLM (Large Language Model) -> Natural language understanding and reasoning
RAG (Retrieval-Augmented Generation) -> External knowledge retrieval
Tool use (Plugins, APIs) -> Calculators, browsers, databases, and more
Planner -> Breaks complex tasks into multiple steps and executes them
Memory -> Remembers past conversations or states to perform continuous tasks

Representative AI Agent Examples

ChatGPT + Tools (OpenAI) -> Can run code, browse the web, and analyze data
AutoGPT, BabyAGI -> Open source autonomous agents
LangChain Agents -> Connect multiple tools to automate workflows
Microsoft Copilot, Google Gemini Agents -> AI assistants integrated with productivity tools

Application Areas of AI Agents

Work automation: Email summarization, schedule management, document generation
Customer support: FAQ answers and consultation support
Research and analysis: Paper search, data analysis, report writing
Development assistance: Code generation, testing, debugging
Robotics: Autonomous driving, drones, smart factories

Summary

An AI Agent goes beyond an LLM that simply answers questions. It is an intelligent system that sets goals, uses tools, and interacts with its environment.
In short, it can be understood as “actionable AI.”

Multi-Model

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

What Is Multi-Model?

It refers to an approach that uses multiple models together in a single AI system.
In other words, instead of assigning everything to a single model, it combines the strengths of each model to achieve better performance or more diverse functions.

For example, it may be a model that can process not only text but also images, audio, and video together.

Why Is It Needed?

When one model is not enough
- Example: When both images and text must be handled
Use of specialized models
- Uses a large general-purpose model together with domain-specific models
Performance optimization
- Heavy and slow models are used only for core reasoning, while lightweight models handle preprocessing and simple tasks
Cost reduction
- Always using a huge model like GPT-4 is expensive, so some tasks are assigned to smaller models and only difficult parts use a larger model

Types of Multi-Model

Different from Multi-Modal
- Multi-Model != Multi-Modal
- Multi-Modal: One model that processes multiple input forms, such as images, text, and speech
- Multi-Model: A system built by combining multiple models
Configuration methods
- Parallel (Ensemble): Multiple models produce answers at the same time, and the results are combined to make the final decision
  - Examples: Voting, blending, weighted sum
- Serial (Pipeline): The output of one model is passed as the input to another model
  - Example: Image captioning model -> text summarization model -> question answering model
- Hybrid: Selects models depending on the situation, such as with a router model

Examples

Retrieval + generation (RAG)
- Retrieval model (vector search) + generative model (LLM)
Copilot-style tools
- Code assistance: a small model for fast code completion, GPT-4 for sophisticated bug fixes
Autonomous driving
- Video recognition CNN + behavior planning RL model
Healthcare
- Medical knowledge model + general LLM combination

Multi-Model vs Single Model

Category	Single Model	Multi-Model
Structure	One model performs everything	Multiple models divide roles
Advantages	Simple and easy to manage	Higher accuracy, more flexibility, and ability to use the latest technologies
Disadvantages	General-purpose models have performance limits	System is complex and requires coordination

Summary

Multi-Model is a system design approach that combines multiple models and uses each model’s strengths to produce better results.

Examples include combining a “retrieval model + generative model,” “small model + large model,” or “specialized model + general-purpose model.”

Function Calling (Tools)

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

What Is Function Calling (Tool Calling)?

Function Calling is a feature that allows an LLM not only to generate text, but also to directly call external functions or APIs.
For example, the function_call feature provided by the OpenAI API is a representative case.

How It Works

User input: “Tell me today’s weather in Seoul”
LLM judgment: “This needs a weather API call”
Tool call: Executes a predefined function, such as getWeather(location: string)
Receive result: { "location": "Seoul", "temp": 28, "condition": "Sunny" }
Generate final response: “Today in Seoul, it is sunny and 28 degrees.”

In other words, the LLM plays the role of converting natural language into function input, while the actual calculation or search is handled by external functions or tools.

Advantages

Use of real-time data
- The LLM itself does not know information after its training point. Function calls can connect it to up-to-date APIs.
Accurate calculation
- LLMs are weak at mathematical operations. Calling a calculator API instead returns accurate results.
Work automation
- “Send an email” -> calls an email API
- “Get the customer list from the DB” -> executes a DB query

Difference Between MCP and Function Calling

Function Calling
- A method where an LLM directly calls individual tools
- Requires call definitions at the API or function level
- Examples: getWeather(), searchStockPrice()
MCP (Model Context Protocol)
- A protocol that connects multiple tools, such as functions and resources, in a standardized way
- Abstracts each tool as a “provider,” allowing the LLM to access them consistently
- A higher-level concept that systematically manages “tool calling,” including function calls

Practical Examples

1. Using Function Calling Alone

OpenAI Function Call example:

{
  "name": "getWeather",
  "description": "Check current weather",
  "parameters": {
    "type": "object",
    "properties": {
      "location": { "type": "string" }
    },
    "required": ["location"]
  }
}

The model maps "Seoul" to location and runs the API.

2. MCP-Based Function Calling

MCP groups functions into a Resource Registry for management
The LLM does not need to know the “weather API” directly; MCP provides an abstracted interface such as tools.weather
Multiple tools are connected through a standard protocol, reducing confusion and duplication in function calls

Analogy

Function Calling = individual “instructions for using a tool” (a single tool such as scissors, a hammer, or a screwdriver)
MCP = “toolbox/workbench” (a system that organizes tools in a standardized way)

Summary

Function Calling is a technology for calling individual APIs, while MCP is a higher-level layer that manages and connects multiple functions or tools in a standardized way.

Vibe Coding

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

Definition of Vibe Coding

Vibe coding is not a formal academic term. It is a phrase recently used in developer communities and means a coding style where programming is done intuitively and enjoyably, following the flow or vibe.
Especially in the AI era, it emphasizes a development style where, instead of writing every line of code directly, developers give goals and feedback in natural language and guide an LLM to generate and modify code.
- Humans focus on “what to build,” while AI handles implementation details.
The term became popular in February 2025 when Andrej Karpathy mentioned the idea of “forgetting the code and fully giving in to the vibe.”

Conceptual Features

Immersion and improvisation
- Coding immediately according to ideas or instincts that come to mind, without a fixed design
- A feeling similar to a musical jam session
Flow-centered
- Freely implements things that “look fun” or “feel like what I want to do now”
- Enjoyment and flow are more important than code perfection
Fast prototyping
- Quickly creates and runs a minimum working feature
- The goal is to make it work first, rather than to build a perfect architecture

Contexts Where Vibe Coding Is Used

Early coding learning -> Maintains motivation through free experimentation
Hackathons/prototype creation -> Useful when ideas must be implemented quickly
Creative work -> Experimental implementation in music, art, games, and more
AI-assisted coding -> Building in flow while conversing with AI such as ChatGPT

Workflow (Typical Steps)

Describe the goal -> Explain the result, such as “process vacation approvals/rejections with a Slack bot”
Generate a draft -> The LLM creates the project skeleton
Run and give feedback -> Point out errors or missing features in natural language and repeat modifications
Expand features/refactor -> Present test criteria and converge toward the target

The key point is that development proceeds based on conversational instructions and feedback.

Pros and Cons

Pros

Easy to express creativity and stay immersed
Fast result checking, making it ideal for prototyping
Motivates learning and experimentation because it is fun and easy to continue
Lowers the entry barrier for non-developers because they can build with AI
Developers move toward a design and quality management role rather than detailed implementation

Cons

Lack of structural completeness and stability
Risk of bugs and security vulnerabilities
Code I did not write directly can be difficult to maintain and debug
Not suitable for complex systems such as multi-file projects or legacy integrations

Difference from AI-Assisted Coding

AI-assisted coding (for example, Copilot) -> I write code, and AI supplements or recommends
Vibe coding -> AI writes most of the code, while the human presents goals, constraints, and tests

Practical Guardrails

Tests first -> Define unit, integration, and E2E tests first
Static analysis/security checks -> Automate linters, SAST, and dependency vulnerability checks
Review and records -> Document requirements, acceptance criteria, and risks, then approve the final result
Sandbox environment -> Use a safe execution space and block sensitive information
Refactoring before production -> Schedule a separate sprint
Fix domain knowledge in place -> Continuously provide API specs, error cases, and performance criteria

Suitable and Unsuitable Cases

Suitable -> Hackathons, PoCs, personal tools, UI/frontend prototypes
Requires caution -> High-trust or regulated environments such as finance, healthcare, and embedded systems

Starter Prompt Template

Goal: What is being built, who uses it, and why
Features: List of required and optional requirements
Constraints/criteria: Security, performance, accessibility, licensing
Tech stack: Language, framework, DB, deployment method
Acceptance criteria: Test scenarios that must pass
Working method: Small PRs, step-by-step testing, commit rule compliance
Example
- “Build a personal shared to-do board with Next.js + SQLite. First propose 5 required features and 3 E2E tests, then implement each feature in a TDD cycle. Security should include OAuth, XSS prevention, and rate limiting.”

Summary

Vibe coding is a development style that follows inspiration and flow rather than formal design, especially using AI to experiment improvisationally and produce results quickly.
It is powerful for prototypes, hackathons, and personal projects, but security, testing, and refactoring are essential for production-level use.

Application Areas of Artificial Intelligence

kc@example.com (kc kim) — Sat, 16 Aug 2025 22:33:00 +0900

Healthcare

Medical image analysis, drug development, and personalized treatment for patients

Example: AI developed by Google’s DeepMind is being used to help detect eye diseases early.
Image source: Robot Newspaper, “Google DeepMind Uses Artificial Intelligence for Early Diagnosis of Eye Diseases”

Real-World Examples of Medical AI

Image diagnosis: AI reads X-ray and MRI images to detect early-stage cancer. At one hospital in the United States, the reading error rate decreased by 20%.
Drug development: Candidate substance discovery, which traditionally took more than 10 years, can be shortened to several months with AI-based methods.
Personalized treatment: Analyzes a patient’s genetic information and recommends the most effective anticancer drug.

Figure 3: Comparison of traditional drug development processes and AI-based processes

Autonomous Driving

Autonomous driving technology aims to recognize road conditions in real time, determine the optimal driving strategy based on them, and manage traffic flow efficiently. It detects the surrounding environment through sensors such as cameras, radar, and LiDAR, and AI algorithms analyze this information to automatically adjust vehicle speed, direction, following distance, and more. This can reduce traffic accidents, improve road efficiency, and strengthen the safety of drivers and pedestrians.

Finance

In finance, AI is applied to many areas, including fraudulent transaction detection, automated investment strategies, and risk management. In fraud detection, it analyzes abnormal transaction patterns in real time to identify suspicious transactions. In automated investment strategy, it optimizes portfolios based on market data. AI is also used to help financial institutions predict and manage credit risk, market risk, and other risks, improving both financial stability and operational efficiency.

Manufacturing

In manufacturing, AI is applied to smart factories, predictive maintenance, automated quality control, and more. Smart factories connect production equipment and logistics systems with AI, enabling efficient process management. Predictive maintenance analyzes sensor data to predict equipment failures in advance and optimizes maintenance plans, reducing costs and time. Automated quality control detects defects that may occur during production in real time and improves product quality.

Education

In education, AI is used to provide personalized learning, automated grading, intelligent tutoring systems, and more. It analyzes each student’s learning level and pace to recommend personalized learning content, and it automatically grades assignments and exams to reduce teachers’ workload. Intelligent tutoring systems also analyze students’ learning patterns, reinforce weak areas, and provide real-time feedback to maximize learning effectiveness.

Ethics and Future Prospects

kc@example.com (kc kim) — Sat, 16 Aug 2025 22:33:00 +0900

Ethical Considerations

The development and spread of artificial intelligence technology bring various ethical issues. The main considerations are as follows.

Privacy protection
- AI systems depend on large amounts of data for learning and operation. In this process, sensitive personal information may be collected and processed, and there is a risk of data leakage or misuse. Therefore, when developing and using AI, compliance with privacy laws and secure data management are essential.
Algorithmic bias
- AI models can learn the biases included in training data as they are. This can lead to unfair judgments or discriminatory outcomes against certain groups or individuals and can undermine social trust. To prevent this, it is necessary to review data bias and design algorithms with fairness in mind.
Replacement of human labor
- AI’s automation capabilities can increase productivity and efficiency while also replacing the roles of some jobs. This can cause changes in employment structures and social inequality, making policy preparation and retraining programs important.
Copyright issues
- Because AI learns from and generates content, it may conflict with someone’s content rights. Copying or modifying copyrighted works without the copyright holder’s permission may constitute copyright infringement.

Is “Ghibli Style” a Copyright Issue?

Specific expressions are protected, but abstract ideas are not.

Creative expression of thoughts and emotions
- Examples: Characters and movie scenes
- Protected by copyright
Idea techniques and methods
- Examples: Style and touch
- Not protected by copyright

Then, is it acceptable to post “Ghibli style” content on the internet? Even if it is not legally problematic, from an AI ethics perspective it cannot be considered appropriate use.

The Future of Artificial Intelligence

Artificial intelligence is expected to evolve beyond a simple tool into a partner that collaborates with humans and supports intelligent decisions. In future society, AI will help human capabilities and maximize efficiency in many fields, including healthcare, education, and industry. However, because technological progress is extremely rapid, if social and legal systems and norms are not developed alongside it, AI can cause various problems such as privacy violations, unfair judgments, and employment insecurity. Therefore, to maximize AI’s potential benefits and minimize side effects, ethical, legal, and social preparation is essential together with technological innovation.

Conclusion

kc@example.com (kc kim) — Sat, 16 Aug 2025 22:33:00 +0900

Conclusion

Artificial intelligence has already become an essential technology across our society. Through this book, we hope readers can properly understand the concepts and principles of AI and use it effectively in their own fields.

Learning Artificial Intelligence

LinkedIn Learning | Generative AI is a tool in service of humanity
- A learning course on the basics of generative AI
LinkedIn Learning | Applying Generative AI as a Creative Professional
- A generative AI course for creators
Gyeonggi Lifelong Learning Portal | Generative AI Course
- A generative AI course