devkuma – devkuma

NotebookLM

Mon, 23 Feb 2026 08:48:00 +0900

NotebookLM 이란?

NotebookLM은 Google 이 개발한 AI 기반 연구·노트 정리 도구이다. 사용자가 업로드한 자료(문서, PDF, 웹 링크 등)를 기반으로 AI가 내용을 이해하고, 요약·정리·질문 응답을 수행하는 개인화된 AI 연구 비서에 가깝다.

기존 챗봇이 일반 지식을 기반으로 답하는 것과 달리, 사용자가 제공한 자료 안에서만 근거를 찾아 답변하는 것이 핵심 특징이다.

Google NotebookLM

주요 특징

자료 기반 답변 (Grounded AI)

업로드한 문서 안에서만 답변 생성
답변에 **출처(인용)**가 함께 제공됨
논문, 계약서, 강의자료 분석에 강점

자동 요약

긴 PDF를 핵심만 정리
핵심 개념, 주장, 결론 구조화
블로그 초안, 보고서 초안 작성에 활용 가능

질문 & 심화 분석

예:

“이 문서의 핵심 주장 3가지는?”
“저자가 전제하는 가정은 무엇인가?”
“비판적으로 분석해줘”

→ 단순 요약을 넘어 비판적 분석, 비교 분석도 가능

오디오 개요 (Audio Overview)

문서 내용을 두 명의 AI가 대화하듯 설명해주는 기능 → 팟캐스트처럼 들을 수 있음

지원 형식

Google Docs
PDF
웹사이트 링크
텍스트 파일
Google Slides

ChatGPT와의 차이점

구분	NotebookLM	ChatGPT
답변 기준	업로드한 자료 중심	일반 학습 데이터 기반
출처 표시	있음	기본적으로 없음
연구 분석	매우 강함	가능하지만 범용적
창의적 글쓰기	보통	매우 강함

이런 사람에게 추천

논문·리서치 작업이 많은 사람
블로그/책 집필을 준비하는 사람
계약서·정책 문서 분석이 필요한 직장인
시험 대비 요약 정리가 필요한 수험생

정리

NotebookLM은 단순한 AI 챗봇이 아니라 “내 자료를 읽고 이해하는 AI 연구 파트너” 에 가깝다.

특히 책을 쓰거나(예: Kotest 책 집필 같은 작업), 자료 기반 콘텐츠를 만들 때 매우 강력한 도구가 될 수 있다.

Google Gemini API를 사용한 MCP 함수 호출

Fri, 30 Jan 2026 16:28:00 +0900

함수 호출 작동 방식

함수 호출 작동 방식에 대해서는 Gemini API 공식 문서에 자세히 설명이 되어 있다.

간단히 설명하면 아래와 같다.

함수 호출은 애플리케이션, LLM, 외부 함수 간의 구조화된 협업 방식이다.
애플리케이션은 먼저 함수 선언을 정의해 함수의 이름, 매개변수, 목적을 모델에 설명을 준비한다.
사용자 프롬프트와 함수 선언을 함께 LLM에 전달하면, 모델은 함수 호출이 필요한지 판단해 구조화된 JSON 응답을 반환하거나 일반 텍스트로 응답한다.
함수 실행은 모델이 아닌 애플리케이션의 책임이며, 모델은 함수 이름과 인수만 제공한다.
실행 결과를 다시 모델에 보내면, 모델이 이를 반영해 사용자 친화적인 최종 답변을 생성한다.

MCP 서버 준비

MCP 서버는 다음 문서에서 설명한 간단히 서버를 활용할 것이다.
Spring, Kotlin를 활용하여 만든 WebMVC MCP Server에 인증 추가하기

클라이언트 개발

클라이언트는 다음 문서에 만든 어플리케이션을 활용할 것이다.
Gemini API를 활용한 어플리케이션 만들기

package com.devkuma.sample1

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


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

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

    // 1. MCP 클라이언트 초기화
    val request = HttpRequest.newBuilder()
        .header("Content-Type", "application/json")
        .header("X-API-key", mcpApiKey)

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

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

    // MCP 서버에서 사용 가능한 도구 목록을 가져옵니다.
    val toolsList = mcpClient.listTools()
    println("Available Tools = $toolsList")


    // 2. Gemini 클라이언트 초기화 및 함수 설정
    val functionDeclarations = toolsList.tools().stream()
        .map({ t ->
            FunctionDeclaration.builder()
                .name(t.name()) // MCP tool name
                .description(t.description()) // MCP tool description
                .parametersJsonSchema(t.inputSchema()) // Object 타입으로 받음
                .build()
        })
        .collect(Collectors.toList())

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

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

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

    // 4. 사용자 질문 처리
    val userMessage = "서울의 날씨를 알려줘"
    println("\n========================================")
    println("User: $userMessage")
    println("========================================\n")



    // 5. 첫 번째 Gemini API 호출
    var response = client.models.generateContent(
        "gemini-3-flash-preview",
        userMessage,
        config
    )

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

    // 6. Function Call 확인 및 처리
    val candidatesOpt = response.candidates()
    if (candidatesOpt.isPresent) {
        val candidates = candidatesOpt.get()
        if (candidates.isNotEmpty()) {
            val candidate = candidates[0]
            val contentOpt = candidate.content()

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

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

                    // Function Call이 있는지 확인
                    val functionCalls = parts.filter { p: Part ->
                        p.functionCall() != null && p.functionCall().isPresent
                    }

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

                        // 대화 히스토리 구성 (사용자 메시지 + 모델의 function call)
                        val contents = mutableListOf<Content>()

                        // 사용자 메시지 추가
                        contents.add(
                            Content.builder()
                                .role("user")
                                .parts(listOf(Part.builder().text(userMessage).build()))
                                .build()
                        )

                        // 모델의 응답 (function call) 추가
                        contents.add(content)

                        // 각 Function Call 처리
                        val functionResponseParts = mutableListOf<Part>()

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

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

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

                                    // 3단계: MCP 서버의 도구 호출
                                    val mcpResult = mcpClient.callTool(CallToolRequest(functionName, functionArgs))
                                    println("MCP Result: $mcpResult")

                                    // MCP 결과에서 content 추출
                                    val mcpContent = mcpResult.content()
                                    val resultText = if (mcpContent.isNotEmpty()) {
                                        // MCP Content를 문자열로 변환
                                        // TextContent의 경우 text 필드를 가짐
                                        val content = mcpContent[0]
                                        when {
                                            content is io.modelcontextprotocol.spec.McpSchema.TextContent -> {
                                                content.text()
                                            }

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

                                    println("Extracted Result: $resultText")

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

                                    functionResponseParts.add(functionResponsePart)
                                }
                            }
                        }

                        // 함수 응답을 user role로 추가
                        contents.add(
                            Content.builder()
                                .role("user")
                                .parts(functionResponseParts)
                                .build()
                        )

                        // 4단계: 함수 호출 결과를 포함하여 Gemini API 재호출
                        println("\n=== Calling Gemini Again with Function Results ===")

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

                        // 7. 최종 응답 출력
                        println("\n=== Final Response ===")
                        println("Assistant: ${response.text()}")
                    } else {
                        println("\nNo function calls detected. Direct response: ${response.text()}")
                    }
                }
            }
        }
    }

    // 8. 정리:MCP 클라이언트 종료
    mcpClient.closeGracefully()
}

Output:

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

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

========================================
User: 서울의 날씨를 알려줘
========================================

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

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

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

=== Final Response ===
Assistant: 서울의 날씨는 좋습니다.

참고 문서

Gemini API | Gemini API를 사용한 함수 호출

Gemini API를 활용한 어플리케이션 만들기

Wed, 28 Jan 2026 18:08:00 +0900

Gemini Key 발급

Google Gemini API를 사용하기 위해서는 API Key를 발급받아야 한다.

1. Gemini Developer API 사이트에 접속

https://ai.google.dev/ 에 접속해서 Explore models in Google AI Studio 버튼을 클릭한다.
처음 접속하면 이용 약관이 표시되는데, 내용을 확인하고 “Continue” 버튼을 클릭한다.

2. Get API Key 발급

Get API Key 메뉴를 선택하면, Key를 발급 받을 수 있다.
이미 발급을 받았다면 목록에 표시가 되었을 것이고, 발급 받은 적이 없다면 API 키 만들기 버튼을 발급 받을 수 있다.

무료 등급

무료 등급은 모델별로 사용량에 제한이 있다. gemini-3-flash 기준으로 일일 최대 요청 수(RPD)가 최대 20번 밖에 되지 않는다.

라이브러리를 활용한 클라이언트 개발

여기서는 Kotlin 언어로 Google GenAI SDK를 활용해서 API를 호출하는 방법을 알아보겠다.

프로젝트 생성

IDE 도구를 이용해서 프로젝트를 생성한다.

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

라이브러리 추가

/build.gradle.kts

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

버전은 GitHub 저장소(googleapis/java-genai) 확인하여 최신 버전을 넣으면 된다.

클라이언트 개발

/src/main/kotlin/Main.kt

package com.devkuma

import com.google.genai.Client

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

    val response =
        client.models.generateContent(
            "gemini-3-flash-preview",
            "인공지능에 대해 한 문장으로 설명하세요.",
            null
        )

    println(response.text())
}

Output:

인공지능은 인간의 학습, 추론, 지각 능력을 컴퓨터 시스템으로 구현하여 기계가 지능적인 작업을 수행할 수 있게 하는 기술입니다.

GEMINI_API_KEY 는 발급 받은 키를 넣으면 된다.

REST

Gemini API는 REST API로도 호출 할 수도 있다.

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [
      {
        "parts": [
          {
            "text": "인공지능에 대해 한 문장으로 설명하세요."
          }
        ]
      }
    ]
  }'

output:

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": "인공지능은 인간의 학습, 추론, 지각 능력을 컴퓨터 시스템으로 구현하여 지적인 작업을 수행할 수 있도록 만든 기술입니다.",
            "thoughtSignature": "Er8OCrwOAXLI2nzqxL3K8LCAB020BPaY+sv89...."
          }
        ],
        "role": "model"
      },
      "finishReason": "STOP",
      "index": 0
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 13,
    "candidatesTokenCount": 32,
    "totalTokenCount": 415,
    "promptTokensDetails": [
      {
        "modality": "TEXT",
        "tokenCount": 13
      }
    ],
    "thoughtsTokenCount": 370
  },
  "modelVersion": "gemini-3-flash-preview",
  "responseId": "5rh6afO6NYb22roPsKr06Ao"
}

참고 문서

Gemini API | Google AI for Developers

위에 예제 코드는 GitHub에서 확인해 볼 수 있다.

Kotlin Exposed

Wed, 24 Dec 2025 10:33:00 +0900

개요

Exposed는 JetBrains가 개발한 Kotlin용 경량 SQL 라이브러리로이다.

https://www.jetbrains.com/ko-kr/exposed/

특징

타입 안정적인 DSL(Domain Specific Language)을 제공한다.
ORM(Object-Relational Mapping) 스타일로 쿼리를 작성할 수 있다.
JDBC 및 R2DBC 드라이버를 지원한다.
트랜잭션 관리, 마이그레이션 등 다양한 기능을 제공한다.
공식적으로 H2, MySQL, MariaDB, Oracle, PostgreSQL, SQL Server, SQLite 데이터베이스를 지원한다.
kotlin 타입 활용 가능하여 컴파일 시점에 타입 오류를 알 수 있다.
DSL, DAO 를 모두 제공해서 용도에 맞게 적합한 것을 선택할 수 있다.
코루틴 호환성: 비동기 프로그래밍을 지원해서 블로킹 작업을 효율적으로 처리할 수 있다.
- Exposed는 내부적으로 JDBC를 사용해서 DB와 통신하고, JDBC는 전통적인 blocking API 이므로 DB 작업을 수행할 때 해당 작업이 완료될 때까지 스레드가 블로킹된다. 따라서 Exposed 자체는 non-blocking API를 제공하지 않지만 코루틴과 함께 사용할 경우 코루틴의 Dispatcher를 활용해서 블로킹 작업을 적절한 스레드 풀에서 실행하도록 관리할 수 있고, 이를 통해 메인 스레드를 차단하지 않고도 DB 작업을 할 수 있다.

데이터베이스 접근 방식

Exposed는 두 가지 레벨의 데이터베이스 access를 제공한다.

SQL을 매핑 한 DSL(Domain Specific Language) 방식
- SQL 과 유사한 형태로 쿼리를 작성할 수 있어서 익숙한 SQL 개념을 사용하면서도 kotlin 이 제공하는 타입 안정성의 이점을 얻을 수 있다.
경량화한 DAO(Data Access Object) 방식
- 전통적인 ORM 프레임워크인 Hibernate와 유사하게 객체지향적 접근 방식을 제공한다.
- 객체 중심으로 DB 엔티티를 다루고, 테이블을 클래스로 표현하므로 DB 레코드를 직접 객체로 매핑할 수 있다.

// DSL 방식
val users = UsersTable.select { UsersTable.age greater 20 }

// DAO 방식
val user = User.findById(1)

프로젝트의 요구사항에 가장 적합한 방식을 선택할 수 있다.

Spring에 적용하는 gRPC 라이브러리 비교

Sat, 15 Nov 2025 21:37:00 +0900

개요

Spring 환경에 gRPC를 적용하는 방법은 크게 2가지 라이브러리가 있다.

net.devh:grpc-server-spring-boot-starter
org.springframewor.grpc:spring-grpc-spring-boot-starter

두 라이브러리는 Spring 환경에 gRPC를 붙인다는 점에서는 비슷하지만, 출신·철학·설계·지원 방식·미래성이 크게 다르다.

본인의 프로젝트 어떤 라이브러리를 적용해야 할지 비교 내용을 확인하고 선택하길 바란다.

라이브러리 비교

항목	net.devh:grpc-server-spring-boot-starter	org.springframework.grpc:spring-grpc-spring-boot-starter
출처	커뮤니티/오픈소스 (3rd-party)	Spring 공식 프로젝트 (Spring Team이 개발)
안정성	오랫동안 널리 사용됨	아직 초기(1.0 전후), 빠르게 발전 중
최신성	Spring Boot 3, Native 지원 부족	Spring Boot 3 / AOT / Native 완전 지원
아키텍처	gRPC 서버/클라이언트 Wrapping 중심	Spring 관점의 신규 gRPC 추상화 제공
의존성 구조	netty 기반의 직접 gRPC 통합	Spring Framework 6 기반 추상화 + AutoConfig
클라이언트 방식	직접 Stub 생성 + annotation 기반 주입	채널 팩토리 기반, Spring Bean 방식
확장성	Interceptor 등 기존 방식 고착	Spring 생태계에 맞춘 고급 확장 기능 가능
장기적 미래	유지보수는 하지만 성장 둔화	Spring 공식 표준으로 자리잡을 가능성 높음

출신과 배경

net.devh (전통적인 방식)

커뮤니티에서 오래전부터 만들어진 3rd-party 외부 라이브러리
Spring Boot 1.x ~ 2.x 시절부터 gRPC를 쉽게 붙이기 위해 시작됨
기업에서 꽤 많이 사용했고, 안정성이 높음
하지만 Spring 팀이 만든 게 아님
최근에는 “유지보수는 하지만 새로운 기능은 적음”

Spring gRPC (신규, 공식)

Spring 프로젝트 공식 gRPC 지원
Spring Framework 6 / Boot 3 에 맞춰 새롭게 설계됨
Spring 팀이 직접 관리하는 미래 지향 프로젝트
AOT, Native Image, Observability 등 Spring 생태계와 완전 호환

설계 철학 및 아키텍처 차이

net.devh

gRPC의 원래 Netty 기반 서버를 Spring 방식으로 감싼 것
@GrpcService, @GrpcClient 등을 제공
Stub이나 Channel을 직접 관리하는 형태
확장성은 있지만 Spring스럽지 않은 부분이 많음
“Spring 애플리케이션 안에 gRPC를 집어넣는다"는 느낌

Spring gRPC

gRPC 기능을 Spring Framework의 개념 안으로 재해석
채널 추상화, 서버 추상화, Bean 구성까지 Spring 방식으로 설계
gRPC = Spring의 1급 지원 기능으로 편입
net.devh처럼 그냥 Wrapping한 것이 아님
Spring AOT(Native), GraalVM, Observability(Micrometer)와 함께 동작하도록 설계

→ 즉, 단순 통합이 아니라 “Spring스러운 gRPC 구현체"라고 보면 됨.

사용 방식 비교

net.devh

서비스 등록

@GrpcService
public class HelloServiceImpl extends HelloServiceGrpc.HelloServiceImplBase { ... }

클라이언트 주입

@GrpcClient("myService")
private HelloServiceGrpc.HelloServiceBlockingStub stub;

Stub은 자동 주입되지만 내부 구현이 다소 난해
클라이언트 채널 관리가 덜 투명함

Spring gRPC

서비스 등록 → BindableService 빈을 등록하면 자동 인식

@Service
class HelloServiceImpl : HelloServiceGrpcKt.HelloServiceCoroutineImplBase()

클라이언트 생성 → 채널 팩토리로 gRPC 채널을 만들고 Stub 직접 주입

@Bean
fun helloStub(factory: GrpcChannelFactory) =
    HelloServiceGrpcKt.HelloServiceCoroutineStub(factory.createChannel("local"))

Spring Bean 시스템에 완전히 통합된 API
Spring Cloud LoadBalancer, Metrics, AOT 등과 자연스럽게 동작

성숙도 및 실제 운영에서의 평가

항목	net.devh	spring-grpc
성숙도	매우 높음	아직 초기
대기업 실제 사용	많음	점점 증가 중
Spring Boot 3 / AOT	일부 제한적	완전 지원
문서	GitHub 위키 중심	Spring 공식 문서 시스템
확장성	기존 gRPC 방식 그대로	Spring-native 확장 가능

어떤 걸 선택해야 하나?

즉시 안정성이 중요하면 → net.devh 추천

기존 기업 레거시/대규모 프로젝트 호환성 최고
문서 많고 예제 많음
이미 검증된 방식

장기적으로 최신 Spring 기술을 쓴다면 → Spring gRPC 추천

Spring Boot 3.x / Spring 6.x 와 최적화됨
공식이기 때문에 Spring 에코시스템과 긴밀하게 진화
AOT + GraalVM Native Image 최적

절대로 섞어쓰면 안 됨

두 라이브러리는 내부적으로 서버 · Stub 관리 방식이 완전히 다르므로 공존이 불가능함.

결론

net.devh

3rd party
오래 사용됨, 안정적
Spring Boot 1.x~2.x 시대의 솔루션
앞으로 큰 신규 기능은 기대 어려움

Spring gRPC

Spring 공식 프로젝트
Boot 3 / Spring 6 / Native / Observability 등 현대적 기능 지원
향후 Spring 진영의 표준 gRPC 솔루션이 될 가능성이 큼

gRPC란 무엇인가?

Sat, 15 Nov 2025 17:05:00 +0900

gRPC란?

gRPC는 Google에서 개발한 고성능, 범용 오픈소스 RPC(Remote Procedure Call) 프레임워크로, 서로 다른 서비스 간의 통신을 빠르고 효율적으로 수행하기 위해 만들어진 기술이다.

gRPC는 “네트워크 너머에 있는 함수를, 마치 내 코드 안의 함수처럼 호출할 수 있게 해주는 기술"이다. 즉, 서비스 간에 **원격 함수를 호출하는 방식(RPC)**을 표준화하고, 빠르고 타입 안전한 통신을 가능하게 한다.

전통적인 REST 기반 통신이 주로 HTTP/1.1과 JSON을 사용하여 데이터를 주고받는 것과 달리, gRPC는 HTTP/2 프로토콜과 **Protocol Buffers(ProtoBuf)**라는 이진 직렬화 포맷을 기반으로 한다. 이러한 기술적 특성 덕분에 gRPC는 낮은 지연 시간, 높은 처리량, 경량의 메시지 크기로 빠르고 효율적인 통신을 할 수 있다.

또한 gRPC는 서비스 간 API를 .proto 파일로 명세함으로써, 서버와 클라이언트가 동일한 인터페이스 정의를 공유하도록 하며, 여러 프로그래밍 언어에 대한 자동 Stub 생성을 지원한다. 이러한 구조는 다중 언어 환경에서의 개발을 용이하게 하고, 서비스 경계를 명확히 하여 유지보수성을 크게 향상시킨다.

출처: https://appmaster.io/ko/blog/grpcneun-mueosibnigga

gRPC의 핵심 요소

1. Protocol Buffers(프로토콜 버퍼) 기반

gRPC는 JSON 대신 **프로토콜 버퍼(ProtoBuf)**라는 바이너리 포맷을 사용한다.

JSON보다 작고 빠름
명확한 스키마(protobuf 파일) 기반
각 언어로 자동으로 Stub 코드(클라이언트/서버 코드) 생성

예: hello.proto

service HelloService {
  rpc SayHello (HelloRequest) returns (HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

2. HTTP/2 기반 통신

gRPC는 내부적으로 HTTP/2 프로토콜을 사용합니다.

그래서 다음이 가능합니다:

Multiplexing (하나의 연결로 여러 요청)
Server Push
헤더 압축
스트리밍(양방향 포함)

즉, REST보다 더 빠르고 효율적인 구조입니다.

gRPC 통신 방식 (4가지)

유형	설명
Unary	가장 기본적인 1요청 → 1응답
Server Streaming	서버가 여러 메시지를 스트림으로 전달
Client Streaming	클라이언트가 여러 메시지를 보내서 서버가 한 번 응답
Bidirectional Streaming	클라이언트와 서버가 동시에 여러 메시지를 주고받음

예: 채팅, 실시간 로그 처리, 스트리밍 데이터 처리에 적합

gRPC의 장단점

장점

빠르고 가벼운 통신
- 프로토콜 버퍼 + HTTP/2 조합으로 매우 고성능.
강력한 타입 안정성
- proto 스키마 기반으로 컴파일 시 오류 확인 가능.
멀티언어 지원
- Go, Java, Kotlin, Python, Rust, C#, Node, Ruby 등 대부분의 언어에서 사용 가능.
스트리밍 지원
- REST에서는 어렵거나 번거로운 양방향 스트리밍을 기본으로 지원.
마이크로서비스에 최적화
- 내부 통신은 REST보다 gRPC 채택률이 높음.

단점

브라우저 직접 호출 어려움 (WebAssembly나 gRPC-Web 필요)
개발자가 proto 작성, 컴파일 과정 이해 필요
디버깅이 REST보다 불편

언제 gRPC를 써야 하나?

적합한 경우

마이크로서비스 내부 통신
고성능이 중요한 트래픽
실시간 스트리밍 서비스
다국어 서비스(서버는 Java, 클라이언트는 Go 등)
IoT, 게임 서버, 실시간 이벤트 처리

REST가 더 나은 경우

브라우저 직접 호출 API
단순한 public API
사람이 읽기 편한 포맷이 필요할 때(JSON)

아래는 gRPC vs REST 차이를 한눈에 볼 수 있도록 정리한 비교 표입니다. 실무에서 판단 기준으로 쓰기 좋은 항목들만 골랐습니다.

gRPC vs REST 비교표

구분	gRPC	REST
통신 프로토콜	HTTP/2	HTTP/1.1 (HTTP/2도 가능하나 대부분 1.1)
데이터 포맷	Protocol Buffers(바이너리)	JSON, XML 등 텍스트 기반
속도	매우 빠름 (JSON보다 작고 parsing 효율적)	상대적으로 느림
스트리밍 지원	완전 지원 (양방향 스트리밍)	제한적 (Server-Sent Events / WebSocket 별도 필요)
인터페이스 정의	`.proto` 파일에서 타입·스키마 명확하게 정의	별도의 스키마 강제 없음(오픈 API 권장)
타입 안정성	컴파일 타임 검증 가능	런타임에 검증되는 경우가 많음
코드 생성	서버/클라이언트 Stub 자동 생성	Swagger/OpenAPI로 문서화는 가능하지만 Stub은 필수 아님
사용 편의성	브라우저 직접 호출 어려움(gRPC-Web 별도 필요)	브라우저/JavaScript에서 바로 사용 가능
인간 가독성	낮음 (바이너리)	높음(JSON 읽기 쉬움)
디버깅	어려움 (바이너리 포맷)	쉬움 (REST는 Curl·Postman으로 바로 요청 가능)
보안	TLS+HTTP/2 조합 매우 강력	표준적 TLS 보안
적합한 서비스	마이크로서비스 내부 통신, 고성능, 실시간 스트리밍	Public API, 외부 서비스 연동, 브라우저 중심 서비스
언어 지원	거의 모든 언어 공식 지원	언어 무관 (HTTP 지원하면 됨)
장점 요약	빠름, 효율적, 타입 안전, 스트리밍 강력	단순함, 디버깅 쉬움, 호환성 높음
단점 요약	복잡, 브라우저 접근성 낮음	성능 열세, 타입 안전성 부족

결론 요약

gRPC: 내부 통신/고성능/스트리밍에 최적
REST: 브라우저·대중 API·디버깅 편의성에 최적

Spring에 net.devh 라이브러리를 활용한 gRPC 구현

Sat, 15 Nov 2025 17:05:00 +0900

개요

Spring에 Kotlin와 커뮤니티/오픈소스(3rd-party) 라이브러리인 net.devh를 활용한 간단한 gRPC 구현을 해보겠다.

목표

Spring Boot 프로젝트에 커뮤니티/오픈소스(3rd-party) 라이브러리인 net.devh를 활용하여 gRPC 서버를 연동
.proto 파일 작성 및 Stub 자동 생성
gRPC 서비스 구현
gRPC 클라이언트 작성 및 호출

프로젝트 생성

프로젝트 생성은 Spirng ininitializr으로 생성할 수 있다.

화면 아래 부근에 “GENERATE” 버튼을 누르면, 설정한 프로젝트 파일을 다운로드를 받을 수 있다.

또는, 다음과 같이 curl 명령어를 사용하여 Spring Boot 초기 프로젝트를 생성할 수도 있다.

curl https://start.spring.io/starter.tgz \
-d bootVersion=3.5.7 \
-d baseDir=spring-grpc-1 \
-d groupId=com.devkuma \
-d artifactId=spring-grpc \
-d packageName=com.devkuma.grpc \
-d applicationName=GrpcApplication \
-d packaging=jar \
-d language=kotlin \
-d javaVersion=21 \
-d description="Demo project for Spring gRPC" \
-d type=gradle-project-kotlin | tar -xzvf -

빌드 스크립트 설정

빌드 스크립트에 gRPC 관련 라이브러리를 추가하고, protobuf 설정을 작성한다.

build.gradle

plugins {
	kotlin("jvm") version "1.9.25"
	kotlin("plugin.spring") version "1.9.25"
	id("org.springframework.boot") version "3.5.7"
	id("io.spring.dependency-management") version "1.1.7"

    // gRPC
    id("com.google.protobuf") version "0.9.5"
}

group = "com.devkuma"
version = "0.0.1-SNAPSHOT"
description = "Demo project for Spring gRPC"

java {
	toolchain {
		languageVersion = JavaLanguageVersion.of(21)
	}
}

repositories {
	mavenCentral()
}

dependencies {
	implementation("org.springframework.boot:spring-boot-starter")
	implementation("org.jetbrains.kotlin:kotlin-reflect")
	testImplementation("org.springframework.boot:spring-boot-starter-test")
	testImplementation("org.jetbrains.kotlin:kotlin-test-junit5")
	testRuntimeOnly("org.junit.platform:junit-platform-launcher")

    // gRPC + protobuf
    implementation("io.grpc:grpc-kotlin-stub:1.4.3")
    implementation("io.grpc:grpc-protobuf:1.75.0")
    implementation("io.grpc:grpc-stub:1.75.0")
    implementation("io.grpc:grpc-netty-shaded:1.75.0")
    implementation("com.google.protobuf:protobuf-kotlin:3.22.3")

    // Spring gRPC Starter
    implementation("net.devh:grpc-server-spring-boot-starter:3.1.0.RELEASE")
}

kotlin {
	compilerOptions {
		freeCompilerArgs.addAll("-Xjsr305=strict")
	}
}

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:3.24.4"
    }

    plugins {
        register("grpc") {
            artifact = "io.grpc:protoc-gen-grpc-java:1.75.0"
        }
    }

    generateProtoTasks {
        all().forEach { task ->
            task.plugins {
                create("grpc")
            }
        }
    }
}

tasks.withType<Test> {
    useJUnitPlatform()
}

Protobuf 파일 작성

src/main/proto 디렉토리에 gRPC 서비스와 메시지를 정의한 .proto 파일을 작성한다.

**src/main/proto/hello.proto

syntax = "proto3";

option java_multiple_files = true;
option java_package = "com.devkuma.grpc";
option java_outer_classname = "HelloProto";

service HelloService {
  rpc SayHello(HelloRequest) returns (HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

gRPC 서버 구현

Service 객체 생성

src/main/kotlin/com/devkuma/grpc/service/HelloServiceImpl.kt

package com.devkuma.grpc.service

import com.devkuma.grpc.HelloRequest
import com.devkuma.grpc.HelloResponse
import com.devkuma.grpc.HelloServiceGrpc
import net.devh.boot.grpc.server.service.GrpcService
import io.grpc.stub.StreamObserver

@GrpcService
class HelloServiceImpl : HelloServiceGrpc.HelloServiceImplBase() {

    override fun sayHello(
        request: HelloRequest,
        responseObserver: StreamObserver<HelloResponse>
    ) {
        val reply = "Hello, ${request.name}!"

        val response = HelloResponse.newBuilder()
            .setMessage(reply)
            .build()

        responseObserver.onNext(response)
        responseObserver.onCompleted()
    }
}

서버 설정

기본 gRPC 포트는 9090이다.
원하면 application.yml로 변경 가능하다.

src/main/kotli/resources/application.yml

grpc:
  server:
    port: 9090

gRPC 클라이언트 구현

같은 프로젝트에서 테스트를 하기 위해, 클라이언트 설정 Bean을 추가한다.

클라이언 설정

src/main/kotlin/com/devkuma/grpc/client/GrpcClientConfig.kt

package com.devkuma.grpc.client

import com.devkuma.grpc.HelloServiceGrpc
import io.grpc.ManagedChannel
import io.grpc.ManagedChannelBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration
class GrpcClientConfig {

    @Bean
    fun helloChannel(): ManagedChannel =
        ManagedChannelBuilder
            .forAddress("localhost", 9090)
            .usePlaintext()
            .build()

    @Bean
    fun helloStub(channel: ManagedChannel): HelloServiceGrpc.HelloServiceBlockingStub =
        HelloServiceGrpc.newBlockingStub(channel)
}

gRPC Stub을 호출하는 Service 생성

단순히 stub을 호출하는 Service를 생성한다.

src/main/kotlin/com/devkuma/grpc/client/HelloGrpcClientService.kt

package com.devkuma.grpc.client

import com.devkuma.grpc.HelloRequest
import com.devkuma.grpc.HelloServiceGrpc
import org.springframework.stereotype.Service

@Service
class HelloGrpcClientService(
    private val helloStub: HelloServiceGrpc.HelloServiceBlockingStub,
) {

    fun sayHello(name: String): String {
        val request = HelloRequest.newBuilder()
            .setName(name)
            .build()

        val response = helloStub.sayHello(request)
        return response.message
    }
}

테스트

서버와 클라이언트를 하나의 프로젝트에 넣었기에, 테스트 파일 1개로 테스트가 가능하다.

package com.devkuma.grpc

import com.devkuma.grpc.client.HelloGrpcClientService
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import kotlin.text.contains

@SpringBootTest
class GrpcIntegrationTest {

    @Autowired
    lateinit var client: HelloGrpcClientService

    @Test
    fun testSayHello() {
        val result = client.sayHello("devkuma")
        assert(result.contains("devkuma"))

        println(result)
    }
}

output:

Hello, devkuma!

참고

위에 예제 코드는 GitHub에서 확인해 볼 수 있다.

Spring 공식 프로젝트 라이브러리를 활용한 gRPC 구현

Sat, 15 Nov 2025 17:05:00 +0900

개요

Spring 공식 프로젝트(Spring Team이 개발) gRPC 라이브러리를 활용한 gRPC 구현을 해보겠다.

목표

Spring Boot 프로젝트에 Spring 공식 프로젝트 gRPC 라이브러리를 활용한 gRPC 서버를 연동
.proto 파일 작성 및 Stub 자동 생성
gRPC 서비스 구현
gRPC 클라이언트 작성 및 호출

프로젝트 생성

프로젝트 생성은 Spirng ininitializr으로 생성할 수 있다.

화면 아래 부근에 “GENERATE” 버튼을 누르면, 설정한 프로젝트 파일을 다운로드를 받을 수 있다.

또는, 다음과 같이 curl 명령어를 사용하여 Spring Boot 초기 프로젝트를 생성할 수도 있다.

curl https://start.spring.io/starter.tgz \
-d bootVersion=3.5.7 \
-d dependencies=spring-grpc \
-d baseDir=spring-grpc-2 \
-d groupId=com.devkuma \
-d artifactId=spring-grpc \
-d packageName=com.devkuma.grpc \
-d applicationName=GrpcApplication \
-d packaging=jar \
-d language=kotlin \
-d javaVersion=21 \
-d description="Demo project for Spring gRPC" \
-d type=gradle-project-kotlin | tar -xzvf -

빌드 스크립트 설정

빌드 스크립트에 gRPC 관련 라이브러리를 추가하고, protobuf 설정을 작성한다.

build.gradle

import com.google.protobuf.gradle.id

plugins {
    kotlin("jvm") version "1.9.25"
    kotlin("plugin.spring") version "1.9.25"
    id("org.springframework.boot") version "3.5.7"
    id("io.spring.dependency-management") version "1.1.7"

    // gRPC
    id("com.google.protobuf") version "0.9.5"
}

group = "com.devkuma"
version = "0.0.1-SNAPSHOT"
description = "Demo project for Spring gRPC"

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

repositories {
    mavenCentral()
}

extra["springGrpcVersion"] = "0.12.0"

dependencies {
    implementation("io.grpc:grpc-services")
    implementation("org.jetbrains.kotlin:kotlin-reflect")
    implementation("org.springframework.grpc:spring-grpc-spring-boot-starter") // Spring gRPC Starter
    testImplementation("org.springframework.boot:spring-boot-starter-test")
    testImplementation("org.jetbrains.kotlin:kotlin-test-junit5")
    testImplementation("org.springframework.grpc:spring-grpc-test")
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")

    // Kotlin coroutines
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")

    // gRPC + protobuf
    implementation("io.grpc:grpc-kotlin-stub:1.4.3")
    implementation("io.grpc:grpc-protobuf:1.75.0")
    implementation("io.grpc:grpc-stub:1.75.0")
    implementation("io.grpc:grpc-netty-shaded:1.75.0")
}

dependencyManagement {
    imports {
        mavenBom("org.springframework.grpc:spring-grpc-dependencies:${property("springGrpcVersion")}")
    }
}

kotlin {
    compilerOptions {
        freeCompilerArgs.addAll("-Xjsr305=strict")
    }
}

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc"
    }
    plugins {
        id("grpc") {
            artifact = "io.grpc:protoc-gen-grpc-java"
        }
        id("grpckt") {
            artifact = "io.grpc:protoc-gen-grpc-kotlin:1.4.3:jdk8@jar"
        }
    }
    generateProtoTasks {
        all().forEach {
            it.plugins {
                id("grpc") {
                    option("@generated=omit")
                }
                id("grpckt") {
                    option("@generated=omit")
                }
            }
        }
    }
}

tasks.withType<Test> {
    useJUnitPlatform()
}

Protobuf 파일 작성

src/main/proto 디렉토리에 gRPC 서비스와 메시지를 정의한 .proto 파일을 작성한다.

**src/main/proto/hello.proto

syntax = "proto3";

option java_multiple_files = true;
option java_package = "com.devkuma.grpc";
option java_outer_classname = "HelloProto";

service HelloService {
  rpc SayHello(HelloRequest) returns (HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

gRPC 서버 구현

Service 객체 생성

src/main/kotlin/com/devkuma/grpc/service/HelloServiceImpl.kt

package com.devkuma.grpc.service

import com.devkuma.grpc.HelloRequest
import com.devkuma.grpc.HelloResponse
import com.devkuma.grpc.HelloServiceGrpcKt
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.springframework.stereotype.Service

@Service
class HelloServiceImpl : HelloServiceGrpcKt.HelloServiceCoroutineImplBase() {

    override suspend fun sayHello(request: HelloRequest): HelloResponse =
        withContext(Dispatchers.Default) {
            val message = "Hello, ${request.name}! (from Spring gRPC Kotlin)"

            HelloResponse.newBuilder()
                .setMessage(message)
                .build()
        }
}

서버 설정

기본 gRPC 포트는 9090이다.
원하면 application.yml로 변경 가능하다.

src/main/kotli/resources/application.yml

spring:
  grpc:
    server:
      port: 9090

gRPC 클라이언트 구현

같은 프로젝트에서 테스트를 하기 위해, 클라이언트 설정 Bean을 추가한다.

클라이언 설정

src/main/kotlin/com/devkuma/grpc/client/GrpcClientConfig.kt

package com.devkuma.grpc.client

import com.devkuma.grpc.HelloServiceGrpcKt
import io.grpc.ManagedChannel
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.grpc.client.GrpcChannelFactory

@Configuration
class GrpcClientConfig {

    @Bean
    fun helloStub(channelFactory: GrpcChannelFactory): HelloServiceGrpcKt.HelloServiceCoroutineStub {
        val channel: ManagedChannel = channelFactory.createChannel("local")
        return HelloServiceGrpcKt.HelloServiceCoroutineStub(channel)
    }
}

gRPC Stub을 호출하는 Service 생성

단순히 stub을 호출하는 Service를 생성한다.

src/main/kotlin/com/devkuma/grpc/client/HelloGrpcClientService.kt

package com.devkuma.grpc.client

import com.devkuma.grpc.HelloRequest
import com.devkuma.grpc.HelloServiceGrpcKt
import org.springframework.stereotype.Service

@Service
class MyGrpcClientService(
    private val helloStub: HelloServiceGrpcKt.HelloServiceCoroutineStub
) {

    suspend fun sayHello(name: String): String {
        val request = HelloRequest.newBuilder()
            .setName(name)
            .build()

        val response = helloStub.sayHello(request)
        return response.message
    }
}

테스트

서버와 클라이언트를 하나의 프로젝트에 넣었기에, 테스트 파일 1개로 테스트가 가능하다.

package com.devkuma.grpc

import com.devkuma.grpc.client.MyGrpcClientService
import kotlinx.coroutines.runBlocking
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest

@SpringBootTest
class GrpcIntegrationTest {

    @Autowired
    lateinit var client: MyGrpcClientService

    @Test
    fun testSayHello() = runBlocking {
        val result = client.sayHello("devkuma")
        assert(result.contains("devkuma"))

        println(result)
    }
}

output:

Hello, devkuma!

참고

위에 예제 코드는 GitHub에서 확인해 볼 수 있다.

Spring, Kotlin를 활용하여 만든 WebMVC MCP Server에 인증 추가하기

Sun, 09 Nov 2025 10:06:00 +0900

시작하기

앞에서는 WebMVC 전송 방식의 MCP Server를 만들었다면, 여기서는 서버에 인증 기능을 추가헤 보도록 하겠다.

Spring-AI에서는 Spring Security으로 서버 인증으로 OAuth2와 ApiKey 인증 방식을 제공하고 있다.

2025-11-10 기준으로 아직 MCP Security은 구현중에 있으며, 안정적이지 않다고 한다.

여기에서는 WebMVC MCP Server에 ApiKey 인증 방식을 적용해 보겠다.

WebMVC MCP Server에 인증 추가

이번에도 기존 만들었던 WebMVC 방식의 MCP Server 코드를 그대로 사용하도록 하겠다.

기존 코드 복사

기존에 작성한 코드가 있다면 디렉토리 통채로 복사하여 사용하도록 하겠다.

작성한 코드가 없다면, GitHub를 통채로 복사해서 사용해도 된다.

코드를 복사하고, 디렉토리도 다음과 같이 변경한다.

% mv spring-ai-mcp-server-webmvc spring-ai-mcp-server-auth

빌드 스크립트

복사한 프로젝트의 settings.gradle.kts 파일에세 root 프로젝트 이름도 spring-ai-mcp-server-auth 로 변경한다.

settings.gradle.kts

rootProject.name = "spring-ai-mcp-server-auth"

의존성 라이브러리에 Spring Security(spring-boot-starter-security), MCP Server Secutiry(mcp-server-security) 라이브러리를 추가한다.

/build.gradle.kts

dependencies {
	...
	implementation("org.springframework.ai:spring-ai-starter-mcp-server")
  implementation("org.springframework.ai:spring-ai-starter-mcp-server-webmvc") // webmvc 추가
  implementation("org.springframework.boot:spring-boot-starter-security") // auth 추가
  implementation("org.springaicommunity:mcp-server-security:0.0.3") // auth 추가
  ...
}

어플리케이션 설정 파일

application.yml 파일을 다음와 같이 변경한다.

/src/main/resources/application.yml

spring:
  main:
#    web-application-type: none
    # NOTE: You must disable the banner and the console logging to allow the STDIO transport to work !!!
    banner-mode: off
  ai:
    mcp:
      server:
        name: my-weather-server
        version: 0.0.1
        protocol: STATELESS # webmvc 추가

logging:
#  pattern:
#    console:
  file:
    name: ./log/spring-ai-starter-mcp-server-auth.log
  level:
    org.springframework.security: TRACE

로그 파일명(spring-ai-starter-mcp-server-auth.log)이 변경 되었고,
Spring Security 로그 레벨만 추가 되었을 뿐 다른건 수정 된 것이 없다.

logging:
  level:
    org.springframework.security: TRACE

MCP 서버 보안 설정 객체 생성

Spring Security 설정에 MCP Api Key를 등록한다.

/src/main/kotlin/com/devkuma/ai/mcp/server/SecurityConfig.kt

package com.devkuma.ai.mcp.server

import org.springaicommunity.mcp.security.server.apikey.ApiKeyEntityRepository
import org.springaicommunity.mcp.security.server.apikey.memory.ApiKeyEntityImpl
import org.springaicommunity.mcp.security.server.apikey.memory.InMemoryApiKeyEntityRepository
import org.springaicommunity.mcp.security.server.config.McpApiKeyConfigurer.mcpServerApiKey
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.security.config.annotation.web.builders.HttpSecurity
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity
import org.springframework.security.web.SecurityFilterChain

@Configuration
@EnableWebSecurity
class SecurityConfig {

    @Bean
    fun securityFilterChain(http: HttpSecurity): SecurityFilterChain =
        http.authorizeHttpRequests { authorizeHttpRequestsCustomizer ->
            authorizeHttpRequestsCustomizer.anyRequest().authenticated()
        }.with(
            mcpServerApiKey(),
            { apiKey ->
                apiKey.apiKeyRepository(apiKeyRepository())
            }
        ).build()

    private fun apiKeyRepository(): ApiKeyEntityRepository<ApiKeyEntityImpl> {
        val apiKey = ApiKeyEntityImpl.builder()
            .name("test api key")
            .id("api01")
            .secret("mycustomapikey")
            .build()

        return InMemoryApiKeyEntityRepository(listOf(apiKey))
    }
}

인증으로 위한 ID는 api01으로 하고 Secret(비밀키)는 mycustomapikey로 설정한 것을 확인할 수 있다.
ID, Secret는 InMemoryApiKeyEntityRepository 통하여, 메모리에 담기도록 하였다.

여기서는 임시로 어플리케이션 기동시에 메모리에 담기도록 저장고를 만들었지만, 실제에서는 다른 DB나, API 등 다른 방식으로 하기를 권한다.

테스트를 위한 MCP Client 구현

MCP Server는 완성이 되었고, 이제 클라이언트를 구현해 보겠다.

기존에 작성하였던 HttpClient.kt 클라이언트 파일에 인증을 추가한다.

/src/test/kotlin/com/devkuma/ai/mcp/client/HttpClient.kt

package com.devkuma.ai.mcp.client

import io.modelcontextprotocol.client.McpClient
import io.modelcontextprotocol.client.transport.HttpClientStreamableHttpTransport
import io.modelcontextprotocol.spec.McpSchema.CallToolRequest

import java.net.http.HttpRequest

fun main() {
    val request = HttpRequest.newBuilder()
        .header("Content-Type", "application/json")
        .header("X-API-key", "api01.mycustomapikey")

    val transport = HttpClientStreamableHttpTransport.builder("http://localhost:8080")
        .requestBuilder(request)
        .build()

    val client = McpClient.sync(transport)
        .build()

    client.initialize()

    client.ping()

    // List and demonstrate tools
    val toolsList = client.listTools()
    println("Available Tools = $toolsList")

    val alertResult = client.callTool(CallToolRequest("get_weather", mapOf("city" to "seoul")))
    println("get_weather Response = $alertResult")

    client.closeGracefully()
}

Request에 Header에 key는 X-API-key으로 설정하고, value은api01.mycustomapikey로 설정하였다.
설정된 Request에 Header는 transport에 requestBuilder로 설정이 되었다.

Output:

... 생략 ...

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]
get_weather Response = CallToolResult[content=[TextContent[annotations=null, text="The weather in seoul is good.", meta=null]], isError=false, structuredContent=null, meta=null]

... 생략 ...

실행을 해보면 이전에 했던 결과와 동일하게, 사용 가능한 Tool 목록이 표시되고, get_weather 도구를 호출하여 응답을 받은 값을 표시되는 것을 확인할 수 있다.

참고

위에 예제 코드는 GitHub에서 확인해 볼 수 있다.

Spring, Kotlin를 활용하여 간단한 WebMVC MCP Server 만들기

Sun, 09 Nov 2025 09:39:00 +0900

시작하기

앞에서는 Spring으로 STDIO 방식의 MCP Server를 만들었다면, 여기서는 WebMVC 전송 방식의 서버를 만들어 보도록 하겠다.

MVP 프로토콜과 실행 모드

Spring-AI의 MCP Server 프레임워크는 다음과 같은 서버 프로토콜을 제공한다:

STDIO
- Standard Input/Output library
- 프로세스 내부에서 표준 입출력으로 통신
SSE
- Server-Sent Events(실시간 서버-클라이언트 통신 기술)
- 실시간 서버-클라이언트 통신
Streamable-HTTP
- 전통적인 HTTP 통신을 확장해서 스트리밍처럼 작동하도록 만든 방식
- HTTP POST/GET 요청으로 서버에서 여러 클라이언트 연결 처리
Stateless Streamable-HTTP
- AI 모델과 같은 애플리케이션을 위한 통신 프로토콜
- 단일 HTTP 엔드포인트를 통해 요청 전송과 응답 스트리밍을 동시에 수행
- 요청 간 세션 메모리를 유지하지 않음으로써 무상태성을 구현
- 요청 간 세션 상태를 유지하지 않아 MSA 환경에 적합

이 문서에서는 Stateless Streamable-HTTP 방식으로 구현하려고 한다.

MCP Server을 WebMVC 방식으로 변경

기존 만들었던 STDIO 방식의 MCP Server 코드를 그대로 사용하도록 하겠다.

기존 코드 복사

기존에 작성한 코드가 있다면 디렉토리 통채로 복사하여 사용하도록 하겠다.

작성한 코드가 없다면, GitHub를 통채로 복사해서 사용해도 된다.

코드를 복사하고, 디렉토리도 다음과 같이 변경한다.

% mv spring-ai-mcp-server spring-ai-mcp-server-webmvc

빌드 스크립트

복사한 프로젝트의 settings.gradle.kts 파일에세 root 프로젝트 이름도 spring-ai-mcp-server-webmvc 로 변경한다.

settings.gradle.kts

rootProject.name = "spring-ai-mcp-server-webmvc"

의존성 라이브러리에 Spring WebMVC MCP Sever(spring-ai-starter-mcp-server-webmvc) 라이브러리도 추가한다.

/build.gradle.kts

dependencies {
	...
	implementation("org.springframework.ai:spring-ai-starter-mcp-server")
  implementation("org.springframework.ai:spring-ai-starter-mcp-server-webmvc") // webmvc 추가
  ...
}

어플리케이션 설정 파일

application.yml 파일을 다음와 같이 변경한다.

src/main/resources/application.yml

spring:
  main:
#    web-application-type: none
    # NOTE: You must disable the banner and the console logging to allow the STDIO transport to work !!!
    banner-mode: off
  ai:
    mcp:
      server:
        name: my-weather-server
        version: 0.0.1
        protocol: STATELESS # webmvc 추가

logging:
#  pattern:
#    console:
  file:
    name: ./log/spring-ai-starter-mcp-server-webmvc.log

변경된 설정 내용을 확인해 보면, server 설정으로 protocol: STATELESS가 추가되었다.

그리고, yml 파일을 설정을 자세히 보면 다음 로그 설정도 코멘트 처리하여 제거한 것을 볼 수 있다.

spring:
  main:
    web-application-type: none

logging
  pattern
    console:

이 설정을 제거하면, 데몬 웹 프로세스가 기동되고, 콘솔에서 로그도 볼 수 있게 된다.

테스트를 위한 MCP Client 구현

MCP Server는 완성이 되었고, 이제 클라이언트를 구현해 보겠다.

신규로 HttpClient.kt 파일명으로 클라이언트 생성한다.

/src/test/kotlin/com/devkuma/ai/mcp/client/HttpClient.kt

package com.devkuma.ai.mcp.client

import io.modelcontextprotocol.client.McpClient
import io.modelcontextprotocol.client.transport.HttpClientStreamableHttpTransport
import io.modelcontextprotocol.spec.McpSchema.CallToolRequest

fun main() {
    val transport = HttpClientStreamableHttpTransport.builder("http://localhost:8080")
        .build()

    val client = McpClient.sync(transport)
        .build()

    client.initialize()

    client.ping()

    // List and demonstrate tools
    val toolsList = client.listTools()
    println("Available Tools = $toolsList")

    val alertResult = client.callTool(CallToolRequest("get_weather", mapOf("city" to "seoul")))
    println("get_weather Response = $alertResult")

    client.closeGracefully()
}

코드 내용을 보면 HttpClientStreamableHttpTransport 생성시 인자로 http 주소를 넣고 있다.

클라이언트 전에, MCP Sever를 먼저 실행해서 프로세스로 켜놔야 한다. Output:

... 생략 ...

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]
get_weather Response = CallToolResult[content=[TextContent[annotations=null, text="The weather in seoul is good.", meta=null]], isError=false, structuredContent=null, meta=null]

... 생략 ...

STDIO와 동일하게, 사용 가능한 Tool 목록이 표시되고, get_weather 도구를 호출하여 응답을 받은 값을 표시되는 것을 확인할 수 있다.

참고

위에 예제 코드는 GitHub에서 확인해 볼 수 있다.

Claude

Fri, 07 Nov 2025 11:51:00 +0900

개요

Claude는 인공지능(AI) 언어 모델(LLM) 계열로, 미국의 AI 연구 기업 Anthropic이 개발하였다.
2023년 3월 처음 공개되었으며 이후 여러 버전(Claude 2, Claude 3, Claude 4 등)으로 진화해 왔다.
개발 목표 중 하나가 **안전성(Safety)**과 책임 있는 AI 사용이며, 이를 위해 “헌법적 AI(Constitutional AI)” 접근법을 채택하였다.
Claude이란 이름은 프랑스 수학자이자 정보 이론의 선구자인 Claude Shannon에서 따왔다.
ChatGPT처럼 텍스트 기반으로 대화, 요약, 번역, 코드 작성, 문서 분석 등을 수행하는 대화형 AI 모델이다.

버전 및 진화

버전명	출시 시기
Claude 1 (초기)	2023년 초	기본 형태 출시.
Claude 2	2023년 7월	성능·응답 길이 증가.
Claude 3 계열 (Opus, Sonnet, Haiku)	2024년	성능/속도별 모델 라인업 존재. 용도별 다양화.
Claude 4 계열 (예: Opus 4, Sonnet 4.5)	2025년	코드 생성 등 고급 작업에 강함.

특징 및 장점

자연어 대화, 코드 생성, 데이터 분석, 이미지 입력 처리 등 다양한 작업이 가능하도록 설계되어 있다.
최근 버전에서는 **맥락 창(context window)**이 매우 커졌고, 긴 문맥을 다루거나 복잡한 문제 해결에도 강해졌다. 예컨대 Claude Sonnet 4.5 버전은 입력/출력 토큰 단가와 맥락창 등이 개선되었다.
개발자 및 기업 고객용 API, 에이전트(agent) 활용, 툴(tool) 사용 연계 등 실무 활용도 고려되어 있다.

주요 특징

안전성과 투명성 중시
- 사용자에게 해로운 답변을 피하고, 설명 가능한(reasonable) 답변을 제공하는 데 초점을 둠.
긴 문맥 처리
- Claude 3 시리즈는 **최대 200,000 토큰(약 150~200쪽 분량)**까지 이해 가능하여, 긴 문서 분석에 강함.
직관적인 대화
- 사용자의 의도나 뉘앙스를 자연스럽게 파악하는 언어 능력이 뛰어남.
기업용 API 제공
- Slack, Notion, Zapier 등과의 통합 기능을 통해 업무 자동화 및 문서 처리 지원.

ChatGPT와의 차이점

구분	ChatGPT (OpenAI)	Claude (Anthropic)
개발사	OpenAI	Anthropic
대표 모델	GPT-4, GPT-5	Claude 3 시리즈
철학	효율성과 정확성 중심	안전성과 인간 중심적 설계
강점	코드 작성, 다양한 통합 기능	문서 이해력, 윤리적 제어
문맥 길이	약 128k 토큰(GPT-4 Turbo)	약 200k 토큰(Claude 3)

활용 사례

기업에서는 코딩 자동화, 문서 요약, 데이터 분석, 챗봇 응대 등으로 사용하고 있다. 예컨대 코드 리팩토링, 버그 수정 등에서도 언급된다.
일반 사용자도 웹/모바일 채팅 인터페이스로 자연스러운 대화를 나눌 수 있다.
한국 시장 진출 준비 중이며, 국내 기업 및 정책기구와의 협력도 진행 중이다.

한계 및 유의사항

아직 ‘완전한 인공지능’(AGI)이나 자의식 있는 시스템은 아니며, 오류 혹은 허위 정보(“환각(Hallucination)”) 가능성이 존재한다. 예컨대 모델이 잘못된 법적 인용을 생성한 사례가 보도된 바 있다.
기업·단체 이용 시 라이선스, 데이터 보안, 규제 준수 등이 중요하다.
안전성·윤리성 고려가 기업·개발자에게 요구되고 있으며, 특정 국가 기업에 대한 접근 제한 등도 논의되고 있다.

한국 사용자에게 유의할 점

한국어 입력/출력도 가능하지만, 영어 등 원어권에 비해 응답 품질이 조금 떨어질 수 있으므로 중요한 업무에는 검토가 필요하다.
한국 시장 진출 예정이긴 하지만, 지금 당장은 국내 특화 버전이나 로컬화가 완전하지 않을 수 있다.
사용 목적에 따라 무료 또는 유료 플랜으로 나뉠 수 있으며, API 등은 비용이 발생할 수 있다.

Spring AI

Fri, 07 Nov 2025 10:49:00 +0900

Spring AI

Spring, Kotlin를 활용하여 간단한 Standard MCP Server(STDIO) 만들기

Fri, 07 Nov 2025 10:30:00 +0900

시작하기

MCP Server는 AI 모델이 외부 리소스(도구, 데이터, API 등)에 접근할 수 있도록 연결해주는 표준화된 인터페이스를 제공하는 역할을 한다.

MCP 서버에 대한 개념은 아래의 문서를 참고 바란다.
AI 용어 | MCP Server

이 문서에서는 Spring를 활용하여 간단한 MCP Server를 만들고, Claude에서 MCP Server에 연결하는 방법에 대해서 설명한다.

물론, Claude 외에 다른 AI 도구를 활용할 수도 있고, MCP Server도 Spring이 아니어도 된다. MCP는 단어 그대로 Model Content Protocol(모델 컨텐츠 규약)으로 이를 따르고 있어서 가능한 것이다.

MCP Server에서 연결되는 Resoures는 DB, API 등 다양하게 활용될 수 있다. 여기 문서에서는 Resoures는 연결까지는 다루지 않았다.

Spring-AI의 MCP Server 프레임워크는 서버 전송에 따라 아래 3가지 스타타터를 지원한다.

Standard MCP Server
- STDIO서버 전송을 지원
- org.springframework.ai:spring-ai-starter-mcp-server
WebMVC Server 전송
- Spring MVC 기반 SSE(Server-Sent Events) 서버 전송과 옵션으로 STDIO 전송을 지원
- org.springframework.ai:spring-ai-starter-mcp-server-webmvc
WebFlux Server 표준
- Spring WebFlux 기반 SSE(Server-Sent Events) 서버 전송과 옵션으로 STDIO 전송을 지원
- org.springframework.ai:spring-ai-starter-mcp-server-webflux

Spring을 활용한 MCP Server 구현

먼저 Spring와 Kotlin를 활용한 간단한 Standard MCP Server(STDIO)를 생성해 보겠다.

프로젝트 생성

프로젝트 생성은 Spirng ininitializr으로 생성할 수 있다.

화면 아래 부근에 “GENERATE” 버튼을 누르면, 설정한 프로젝트 파일을 다운로드를 받을 수 있다.

또는, 다음과 같이 curl 명령어를 사용하여 Spring Boot 초기 프로젝트를 생성할 수도 있다.

curl https://start.spring.io/starter.tgz \
-d bootVersion=3.5.7 \
-d dependencies=spring-ai-mcp-server \
-d baseDir=spring-ai-mcp-server \
-d groupId=com.devkuma \
-d artifactId=spring-ai-mcp-server \
-d packageName=com.devkuma.ai.mcp.server \
-d applicationName=McpServerApplication \
-d packaging=jar \
-d language=kotlin \
-d javaVersion=21 \
-d description="Demo project for Spring AI MCP Server" \
-d type=gradle-project-kotlin | tar -xzvf -

생성된 프로젝트 확인

빌드 스크립트

의존성 라이브러리에 Spring MVC Server(spring-ai-starter-mcp-server) 라이브러리가 포함되어 있는 것을 볼 수 있다.

/build.gradle.kts

dependencies {
	...
	implementation("org.springframework.ai:spring-ai-starter-mcp-server")
	...
}

Spring AI 라이브러리 버전은 따로 변경하지 않으면 디폴트로 예전 버전이 설정되는데, 여기서는 최신 버전으로 수정한다.

extra["springAiVersion"] = "1.1.0-M4"

최신 버전은 여기에서 확인하면 된다.

Service 객체 생성

MCP Client에서 호출을 하게 되는 서비스 객체를 생성한다.

/src/main/kotlin/com/devkuma/ai/mcp/server/WeatherService.kt

package com.devkuma.ai.mcp.server

import org.springframework.ai.tool.annotation.Tool
import org.springframework.ai.tool.annotation.ToolParam
import org.springframework.stereotype.Service

@Service
class WeatherService {

    @Tool(name = "get_weather", description = "Return the weather of a given city.")
    fun getWeather(@ToolParam(description = "The city for which to get the weather") city: String): String {
        // 실제 날씨 정보를 가져오는 로직을 추가한다.
        // 여기서는 간단히 "Good"을 반환한다.
        return "The weather in $city is good."
    }
}

getWeather(..) 함수에서는 페리미터로 도시(city)를 전달 받고, 날씨의 상태를 고정으로 “good"이라고 응답하도록 만들었다.
- 여기에서는 응답값을 고정으로 넣었지만, 실제로는 다른 리소스(DB, API 등)에서 정보를 가져와서 응답하게 하면 된다.
@Tool에 넣는 Tool에 대한 설명과 @ToolParam에 넣은 페라미터 설명은 나중에 MCP 클라이언트가 서버에 접속을 했을 때, 어떤 도구가 있고 사용 방법은 어떻게 되는지 클라이언트에서 알려줄 수 있다.

MCP 서버 설정 객체 생성

생성된 Service를 Spring 설정으로 AI Tool로 추가한다.

/src/main/kotlin/com/devkuma/ai/mcp/server/McpConfig.kt

package com.devkuma.ai.mcp.server

import org.springframework.ai.tool.ToolCallbackProvider
import org.springframework.ai.tool.method.MethodToolCallbackProvider
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration
class McpConfig {

    @Bean
    fun weatherTools(weatherService: WeatherService): ToolCallbackProvider {
        return MethodToolCallbackProvider.builder().toolObjects(weatherService).build()
    }
}

어플리케이션 설정 파일

application.yml를 다음과 같이 작성한다. (기존에 application.properties은 있다면 yml 파일로 변경한다.)

/src/main/resources/application.yml

spring:
  main:
    web-application-type: none
    # NOTE: You must disable the banner and the console logging to allow the STDIO transport to work !!!
    banner-mode: off
  ai:
    mcp:
      server:
        name: my-weather-server
        version: 0.0.1

logging:
  pattern:
    console:
  file:
    name: ./log/spring-ai-starter-mcp-server.log

여기서 주의점은 banner-mode를 off로 설정해야 한다.

빌드 및 실행 파일 생성

코드 작성이 완료되었다면 빌드하고 jar 파일을 생성을 해야 하는데, IDEA로 gradle 빌드로 boorJar를 실행한다.

또는, 다음과 같이 터미널에서 명령어로 다음과 같이 실행한다.

% ./gradlew clean bootJar

그러면, jar 파일이 아래 경로에 생성된다.

build/libs/spring-ai-mcp-server-0.0.1-SNAPSHOT.jar

테스트를 위한 MCP Client 구현

MCP Server는 완성이 되었고, 이제 클라이언트를 구현해 보겠다.

신규로 StdioClient.kt 파일을 생성한다.

/test/kotlin/com/devkuma/ai/mcp/client/StdioClient.kt

package com.devkuma.ai.mcp.client

import io.modelcontextprotocol.client.McpClient
import io.modelcontextprotocol.client.transport.ServerParameters
import io.modelcontextprotocol.client.transport.StdioClientTransport
import io.modelcontextprotocol.json.McpJsonMapper
import io.modelcontextprotocol.spec.McpSchema.CallToolRequest

fun main() {

    val stdioParams = ServerParameters.builder("java")
        .args(
            "-Dspring.ai.mcp.server.stdio=true",
            "-Dspring.main.web-application-type=none",
            "-Dlogging.pattern.console=",
            "-jar",
            "build/libs/spring-ai-mcp-server-0.0.1-SNAPSHOT.jar"
        )
        .build()

    val transport = StdioClientTransport(stdioParams, McpJsonMapper.createDefault())
    val client = McpClient.sync(transport).build()

    client.initialize()

    // List and demonstrate tools
    val toolsList = client.listTools()
    println("Available Tools = $toolsList")

    val alertResult = client.callTool(CallToolRequest("get_weather", mapOf("city" to "seoul")))
    println("get_weather Response = $alertResult")

    client.closeGracefully()
}

코드 내용을 보면 java 명령어로 jar를 실행하는 stdioParams를 설정하여, StdioClientTransport 생성시에 인자로 넣도 있다.
클라이언트를 하면 STDIO로 MCP Sever가 실행이 된다.

Output:

... 생략 ...

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]
get_weather Response = CallToolResult[content=[TextContent[annotations=null, text="The weather in seoul is good.", meta=null]], isError=false, structuredContent=null, meta=null]

... 생략 ...

실행 결과 출력에는 사용 가능한 Tool 목록이 표시되고, get_weather 도구를 호출하여 응답을 받은 값을 표시되는 것을 확인할 수 있다.

Claude에서 MCP Server에 연결

빌드까지 완료가 되었다면 클로드 데스크탑에 MCP Server에 연결해 보고, 적용이 잘되어 있는지 확인해보도록 하겠다.

연결 설정

MCP Server 연결 설정은 json 파일에 등록해야 한다.

MacOS인 경우에는 ~/Library/Application Support/Claude/claude_desktop_config.json에 설정을 하면된다. (파일이 없다면 새로 생성을 하고, 이미 있다면 추가한다.)

{
  "mcpServers": {
    "spring-ai-mcp-weather": {
      "command": "java",
      "args": [
        "-Dspring.ai.mcp.server.stdio=true",
        "-Dspring.main.web-application-type=none",
        "-Dlogging.pattern.console=",
        "-jar",
        "{{앞에서 만든 프로젝트의 경로}}/spring-ai-mcp-server/build/libs/spring-ai-mcp-server-0.0.1-SNAPSHOT.jar"
      ]
    }
  }
}

생성한 어플리케이션은 java 명령어로 실행이 되고, 실행된 서버는 stdio를 통해서 클로드 데스크탑과 연결이 된다.

연결 설정 확인

Claude를 실행하고 메뉴에서 “Claude > 설정 > 개발자"을 확인해 보면, 로컬 MCP 서버가 추가되어 있는 것을 확인 할 수 있다.
(혹시 여기서 에러가 발생한다면 로그 버튼이 보이는데, 그 버튼을 클릭해서 내용을 확인하면 된다.)

채팅 창에서는 설정 버튼을 누르면 “spring-ai-mcp-wearther"가 활성화 되어 있는 것을 볼 수 있다.

실행 확인

이제 연결이 잘 된 것을 확인했으니, 입력을 해보도로 하겠다.

아래 창에서는 “서울의 날씨는 어때?“라고 입력을 하였다.

그러면, 다음과 같이 “Claude가 spring-ai-mcp-weather에서 Get weather을(를) 사용하려고 합니다.“라는 메세지와 함께, 허용 여부를 묻는다.

허용 버튼을 누르면, 응답으로 “서울 날씨는 좋습니다.“라는 응답하는 것을 볼 수 있다.
“Get weather"를 누르면 요청과 응답에 대해서도 확인할 수 있다.

참고

위에 예제 코드는 GitHub에서 확인해 볼 수 있다.

VectorDB (벡터 데이터베이스)

Thu, 06 Nov 2025 18:12:00 +0900

VectorDB (벡터 데이터베이스) 는 최근 AI·머신러닝·LLM(대형 언어 모델) 분야에서 아주 중요한 역할을 하는 데이터베이스이다.
간단히 말하면, 숫자 벡터 형태의 데이터(=임베딩)를 효율적으로 저장하고 유사한 데이터를 빠르게 찾는 데 특화된 데이터베이스이다.

VectorDB란?

VectorDB는 벡터(Vector) 데이터를 저장·검색·비교하는 데 최적화된 DB이다.
보통 텍스트, 이미지, 오디오, 코드 등 비정형 데이터를 임베딩(embedding) 모델을 통해 고정된 길이의 벡터(숫자 배열)로 변환한 뒤, 이 벡터들을 VectorDB에 저장한다.

예를 들어:

"오늘 날씨 어때?"  →  [0.12, -0.08, 0.56, ... , 0.33]
"지금 비 와?"     →  [0.11, -0.07, 0.57, ... , 0.31]

이 두 벡터는 의미상 비슷하므로 벡터 간 거리(distance) 가 매우 가깝다.
VectorDB는 이런 “유사도 기반 검색"을 빠르게 수행할 수 있도록 만들어진 시스템이다.

VectorDB의 주요 기능

기능	설명
임베딩 저장	텍스트나 이미지 등에서 생성한 벡터를 저장
유사도 검색 (Similarity Search)	쿼리 벡터와 가장 비슷한 벡터(=데이터)를 빠르게 찾아줌
메타데이터 필터링	벡터와 함께 태그, 카테고리 등 부가 정보를 저장하고, 검색 시 필터링 가능
클러스터링/분류	의미상 비슷한 벡터를 그룹화하거나 범주별로 분류
LLM 연동	LLM의 “context”나 “memory” 기능 구현에 자주 사용 (예: RAG 구조)

VectorDB가 중요한 이유

대형 언어 모델(예: GPT, Claude, Gemini 등)은 **한 번에 처리할 수 있는 입력량(Context length)**이 제한되어 있다.
그래서 모든 정보를 LLM에 넣을 수 없다.

이때 VectorDB가 다음처럼 사용된다

사용자의 질문 → 임베딩으로 변환 → VectorDB에서 관련 문서 검색 →
결과를 LLM에 함께 넣어서 답변 생성 (이 구조를 RAG, Retrieval-Augmented Generation 이라고 함)

즉, VectorDB는 LLM의 외부 기억장치처럼 작동한다.

대표적인 VectorDB 제품들

제품명	특징
Pinecone	완전관리형(Managed), API 중심, RAG에 특화
Weaviate	오픈소스 + GraphQL API 지원, Hybrid Search 가능
Milvus	대규모 데이터 처리에 강함, 오픈소스
Qdrant	Rust 기반, 고성능 + 쉬운 REST/gRPC API
FAISS	Meta가 만든 라이브러리 (DB라기보다는 검색 엔진에 가까움)
Chroma	Python 친화적, LangChain 등과 쉽게 연동
Redis Vector Search (Redis 7.2+)	Redis 안에서 벡터 인덱싱 기능 제공

VectorDB 검색의 핵심 개념

벡터 유사도 계산 방법

Cosine similarity (코사인 유사도) — 각 벡터의 방향이 얼마나 비슷한지
Euclidean distance (유클리드 거리) — 두 벡터 간의 직선 거리
Dot product (내적) — 주로 학습된 임베딩에서 사용

인덱싱 (Indexing)

벡터는 보통 수천~수백만 개가 저장되므로, 검색을 빠르게 하기 위해 근사 최근접 탐색(ANN, Approximate Nearest Neighbor) 알고리즘을 사용한다.

대표적인 인덱스 알고리즘:

HNSW (Hierarchical Navigable Small World)
IVF (Inverted File Index)
PQ (Product Quantization)

VectorDB + LLM 예시 (RAG 구조)

flowchart LR
A[사용자 질문] --> B[임베딩 생성기]
B --> C[VectorDB에서 유사 문서 검색]
C --> D[관련 문서 반환]
D --> E[LLM에 문서와 함께 질문 전달]
E --> F[정확하고 맥락 있는 답변 생성]

이 구조를 통해 ChatGPT와 비슷한 “지식 기반 챗봇”을 직접 만들 수 있다.

실제 사용 예시 (Python + Qdrant)

from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct

client = QdrantClient(":memory:")

# 예시 벡터 저장
client.upsert(
    collection_name="docs",
    points=[
        PointStruct(id=1, vector=[0.1, 0.3, 0.5], payload={"text": "안녕하세요"}),
        PointStruct(id=2, vector=[0.11, 0.29, 0.51], payload={"text": "반가워요"})
    ]
)

# 쿼리 벡터와 유사한 데이터 검색
hits = client.search(collection_name="docs", query_vector=[0.12, 0.28, 0.49], limit=2)
print(hits)

🧩 요약

항목	내용
목적	벡터 기반 유사도 검색 및 AI 응용
데이터 형태	고차원 벡터 (embedding)
주요 활용처	RAG, 추천 시스템, 이미지 검색, 음성 검색
핵심 기술	ANN 인덱싱, 코사인 유사도, 메타데이터 필터
대표 제품	Pinecone, Qdrant, Milvus, Weaviate, Chroma

개발과 설계 원칙

Sun, 12 Oct 2025 23:15:05 +0900

Modal과 Dialog의 차이점은?

Sun, 12 Oct 2025 23:15:05 +0900

모달은 사용자가 반드시 상호작용해야만 다른 작업으로 돌아갈 수 있는 **“차단형 UI 창”**을 말한다.

특징
- 배경의 콘텐츠는 비활성화되고 흐리게 처리됨.
- 사용자가 모달 내의 동작(확인, 취소 등)을 마치기 전까지 다른 화면 조작 불가.
- 강제적인 성격이 있음 → 사용자의 흐름을 끊고 특정 작업을 완료하도록 요구.
예시
- “정말 삭제하시겠습니까?“와 같은 확인 창
- 로그인/회원가입 창

Dialog

다이얼로그는 사용자에게 정보를 전달하거나 선택지를 제공하는 대화 상자를 통칭하는 개념이다.

특징
- 모달 다이얼로그: 사용자의 입력을 강제하는 형태 (즉, 모달의 한 종류).
- 모달리스(non-modal) 다이얼로그: 열려 있어도 사용자가 다른 화면을 계속 조작할 수 있음.
- 목적: 단순 안내, 선택 옵션 제공, 사용자와의 상호작용을 위한 가벼운 UI.
예시
- 저장 여부 묻는 알림창
- “업데이트가 있습니다” 알림
- 툴에서 띄우는 옵션 설정 창

Modal과 Dialog의 관계

Modal ⊂ Dialog
즉, 모달은 다이얼로그의 한 형태이다.
모든 모달은 다이얼로그이지만, 모든 다이얼로그가 모달은 아니다.

정리

Dialog: 사용자와 정보를 주고받는 “대화 상자” → 일반적인 상위 개념
Modal: 그 중에서도 사용자의 다른 동작을 막고 특정 입력을 강제하는 “차단형 대화 상자”

AI Q&A

Sat, 30 Aug 2025 18:38:00 +0900

AI에 대해 궁금한 점은 뭐든 정리한다.

바이브 코딩(Vibe Coding)

Sat, 30 Aug 2025 17:55:00 +0900

바이브 코딩(Vibe Coding) 정의

바이브 코딩은 공식적인 학술 용어라기보다는, 최근 개발자 커뮤니티에서 쓰이는 표현으로, 프로그래밍을 감각적으로, 흐름(Vibe, 바이브)에 맞춰 즐기면서 하는 코딩 방식을 뜻한다.
특히 AI 시대에 맞춰, 개발자가 코드 한 줄 한 줄을 직접 짜기보다 자연어로 목표/피드백을 주고 LLM이 코드를 생성·수정하도록 이끄는 개발 방식을 강조한다.
- 사람은 ‘무엇을 만들지’에 집중하고, 구현 세부는 AI가 맡는다.
용어는 2025년 2월 Andrej Karpathy가 “코드는 잊고, 완전히 바이브에 맡긴다"는 취지로 언급하면서 대중화되었다.

개념적 특징

몰입 & 즉흥성
- 정해진 설계 없이, 떠오르는 아이디어나 감각에 따라 바로 코딩
- 음악의 즉흥 연주(jam session) 같은 느낌
흐름(Vibe, 바이브) 중심
- “재밌어 보이는 것”, “지금 하고 싶은 것” 위주로 자유롭게 구현
- 코드의 완벽함보다 즐거움과 흐름이 중요
빠른 프로토타이핑
- 작동하는 최소 기능을 빠르게 만들고 실행
- 완벽한 아키텍처보다 일단 돌아가는 것을 목표

바이브 코딩의 활용 맥락

코딩 학습 초기 → 자유롭게 실험하며 동기 유지
해커톤/프로토타입 제작 → 아이디어를 빠르게 구현해야 할 때
창의적인 작업 → 음악, 아트, 게임 등에서 실험적 구현
AI 활용 코딩 → ChatGPT 같은 AI와 대화하며 흐름대로 구현

워크플로 (일반적인 진행 단계)

목표 서술 → “슬랙 봇으로 휴가 승인/거절 처리"처럼 결과 중심 설명
초안 생성 → LLM이 프로젝트 뼈대 작성
실행·피드백 → 에러/누락된 기능을 자연어로 지적, 반복 수정
기능 확장/리팩터링 → 테스트 기준을 제시해 수렴

→ 핵심은 대화형 지시·피드백을 기반으로 개발이 진행된다는 점.

장단점

장점

창의성 발휘와 몰입 용이
빠른 결과 확인 가능 → 프로토타이핑 최적
학습/실험 동기 부여 (재미있어 오래 지속 가능)
비개발자도 진입 장벽 낮음 (AI와 함께 개발 가능)
개발자는 세밀 구현보다 설계·품질 관리 역할로 이동

단점

구조적 완성도/안정성 부족
버그·보안 취약점 발생 위험
내가 직접 안 짠 코드 → 유지보수/디버깅 어려움
다파일·레거시 연동 같은 복잡한 시스템엔 부적합

AI 보조 코딩과의 차이

AI 보조 코딩 (예: Copilot) → 내가 코드를 작성하면 AI가 보완·추천
바이브 코딩 → AI가 대부분의 코드를 작성, 인간은 목표·제약·테스트만 제시

실무에서의 가드레일 (안전 장치)

테스트 우선 → 단위·통합·E2E 테스트 먼저 정의
정적 분석/보안 점검 → Linter, SAST, 의존성 취약점 자동 검사
리뷰 & 기록 → 요구사항·수용 기준·리스크를 문서화하고 최종 승인
샌드박스 환경 → 안전한 실행 공간, 민감 정보 차단
프로덕션 이전 리팩터링 → 별도 스프린트 편성
도메인 지식 고정 → API 스펙, 에러 케이스, 성능 기준을 지속 주입

적합/부적합 사례

적합 → 해커톤, PoC, 개인 툴, UI/프론트엔드 프로토타입
주의 필요 → 금융, 의료, 임베디드 등 고신뢰/규제 환경

시작용 프롬프트 템플릿

목표: 무엇을, 누가, 왜 쓰는지
기능: 필수·선택 요구사항 목록
제약/기준: 보안, 성능, 접근성, 라이선스
테크스택: 언어·프레임워크·DB·배포 방식
수용 기준: 통과해야 할 테스트 시나리오
작업 방식: 작은 단위 PR, 단계별 테스트, 커밋 규칙 준수
예시
- “Next.js + SQLite로 ‘개인 할 일 공유 보드’를 만들어줘. 필수 기능 5개와 E2E 테스트 3개를 먼저 제안하고, 각 기능을 TDD 사이클로 구현하자. 보안은 OAuth, XSS 방지, rate limit 포함.”

정리

바이브 코딩은 정석적 설계보다는 영감과 흐름에 맞춰, 특히 AI를 활용해 즉흥적으로 실험하고 빠르게 결과를 내는 개발 스타일이다.
프로토타입, 해커톤, 개인 프로젝트에 강력하지만, 프로덕션 수준에는 보안/테스트/리팩터링이 반드시 필요하다

AI 모델에 GPU를 사용하는 이유

Sat, 30 Aug 2025 17:35:00 +0900

AI(특히 딥러닝) 모델은 방대한 데이터를 학습하고 추론하기 위해 막대한 양의 연산을 수행해야 한다. 이때 CPU만으로는 속도가 너무 느려 비효율적이기 때문에, 대규모 병렬 연산에 특화된 GPU가 필수적으로 사용된다.

GPU란 무엇인가?

GPU(Graphic Processing Unit) 는 원래 그래픽 연산(픽셀 렌더링, 3D 그래픽 처리)을 빠르게 수행하기 위해 만들어진 장치이다.
게임이나 영상에서 그래픽이 끊기지 않고 부드럽게 표현되는 것도 GPU의 빠른 병렬 연산 덕분이다.

CPU vs GPU 구조 비교

구분	CPU	GPU
코어 개수	수 개(4 ~ 32개) 고성능 코어	수천 ~ 수만 개의 소형 코어
처리 방식	직렬 처리(Sequential)	병렬 처리(Parallel)
강점	일반적인 로직 수행, 복잡한 분기 처리	대량의 단순 반복 연산, 행렬/벡터 연산
AI 적합성	낮음	매우 높음

딥러닝 학습에 필요한 행렬 곱셈, 벡터 연산이 GPU의 병렬 처리 방식과 딱 맞아떨어진다.

GPU가 AI에 꼭 필요한 이유

병렬 연산 능력

딥러닝 모델은 수많은 파라미터와 뉴런 간 연결을 동시에 계산해야 한다.
GPU는 이를 한꺼번에 병렬 처리해 속도를 비약적으로 향상시킨다.

행렬/벡터 연산 최적화

신경망(Neural Network)은 수많은 행렬(Matrix), 벡터(Vector) 곱셈으로 구성된다.
예: y = Wx + b (가중치 행렬 × 입력 벡터 + 편향)
GPU는 본래 **그래픽 처리(픽셀 계산, 3D 렌더링)**를 위해 행렬 연산 최적화되어 있어, AI 연산과 잘 맞는다.

학습 속도 단축

모델 학습 시 수백만 ~ 수십억 개 파라미터 업데이트 필요하다.
CPU만 사용하면 수 주 ~ 수 개월 걸릴 학습이 GPU를 사용하면 수 시간~~수 일로 단축된다.

대규모 데이터 처리

AI는 이미지, 음성, 텍스트 등 고차원 데이터를 다룬다.
GPU는 대규모 데이터(batch) 연산을 동시에 처리할 수 있어 학습·추론 속도가 빠르다.

추론(Inference) 성능 강화

학습뿐 아니라 실시간 서비스(챗봇 응답, 이미지/음성 인식, 자율주행 센서 데이터 분석 등)에서도 빠른 응답을 제공한다.

생태계 지원

PyTorch, TensorFlow 같은 대표적인 딥러닝 프레임워크가 CUDA(NVIDIA 라이브러리) 기반으로 GPU에 최적화되어 있다.
GPU 사용 시 자동으로 최적화된 커널을 활용할 수 있어 추가 성능 확보 가능하다.

GPU와 AI의 관계

초기 AI 연구자들은 대량의 데이터를 학습시킬 때 CPU만으로는 한계가 있다는 것을 깨달았다. 이때 그래픽 연산용 GPU를 딥러닝 학습에 적용했는데, 병렬 연산 구조가 AI와 완벽히 맞아떨어졌다. 이후로 AI와 GPU는 떼려야 뗄 수 없는 관계가 되었으며, 현재 진행되는 대부분의 AI 연구와 서비스는 GPU 기반에서 이루어진다.

GPU 외 AI 전용 하드웨어

최근에는 GPU 외에도 AI 특화 칩들이 개발되어 활용되고 있다.

TPU (Tensor Processing Unit): Google 개발, 텐서 연산 최적화
NPU (Neural Processing Unit): 모바일 기기용, 에너지 효율 최적화
FPGA, ASIC: 특정 AI 연산에 특화된 맞춤형 칩

하지만 여전히 범용성·성능·생태계 측면에서 GPU가 가장 널리 사용되고 있다.

정리

CPU = 직렬 처리 강점 (범용 프로세서)
GPU = 병렬 연산 특화 (AI·딥러닝 최적화)
AI 모델에 GPU를 사용하는 이유 = 대규모 행렬/벡터 연산을 동시에 빠르게 처리하기 위해서

Google Gemini

Sat, 30 Aug 2025 17:05:00 +0900

Google Gemini란?

Gemini는 Google에서 DeepMind와 Brain 팀의 역량을 통합해 개발한 다중 모드(multimodal) 대형 언어 모델(LLM)이다.
텍스트뿐만 아니라 오디오, 이미지, 동영상 등 다양한 형태의 정보를 이해하고 처리할 수 있는 것이 특징이다.
처음 공개된 것은 2023년 12월로, Gemini 1.0은 Ultra, Pro, Nano 등 세 가지 버전으로 출시되었다. 각각 복잡한 작업, 범용 작업, 장치 내 처리(On-device)를 목표로 했다.
이후 빠르게 발전을 거듭했으며, Gemini 2.5 Flash와 2.5 Pro가 현재 주요 버전으로 사용 중이다. Flash는 응답 속도 중심, Pro는 고도 추론과 코드 생성 기능을 제공하며, Audio 출력 및 보안 기능도 강화되었다.
https://gemini.google.com/

Gemini의 주요 특징

다중 모드(Multimodality)

기존의 AI 모델들이 주로 텍스트에 한정된 것과 달리, Gemini는 텍스트, 이미지, 오디오, 동영상의 다양한 형태의 데이터를 동시에 이해하고 통합적으로 처리할 수 있다.
예를 들어, 동영상을 보면서 내용에 대해 질문하거나, 이미지와 텍스트를 함께 제공하며 특정 작업을 요청할 수 있다.

이미지 편집 (Nano-Banana / Gemini 2.5 Flash Image)

“Nano‑Banana“라 불리는 Gemini 2.5 Flash Image 모델은 사용자가 자연어로 이미지를 수정하거나 합성할 수 있도록 해서, 얼굴·사물 등의 특징을 일관되게 유지하면서 수정해주는 고급 기능을 제공한다.
예를 들어, 여러 이미지를 합치거나 배경 변경, 스타일·의상 수정 등의 작업이 가능하며, AI 생성 이미지에는 눈에 보이거나 보이지 않는 워터마크가 포함되어 있어 생성 여부를 확인할 수 있다.

음성 및 보이스 인터랙션

Gemini Live 기능은 음성을 이용한 실시간 대화형 인터페이스로, 특히 Pixel 9에서 화면 및 카메라 공유와 함께 사용할 수 있다.

다양한 모델

Gemini는 사용 목적에 따라 여러 가지 모델로 나뉜다.
- Gemini Ultra: 가장 강력하고 복잡한 작업에 최적화된 모델이다.
- Gemini Pro: 광범위한 작업에 사용할 수 있는 균형 잡힌 성능의 모델이다.
- Gemini Flash: 비용 효율성과 빠른 응답 속도가 중요한 작업에 적합한 모델이다.

뛰어난 성능

Gemini는 복잡한 추론, 코딩, 수학 문제 해결 등 다양한 벤치마크에서 뛰어난 성능을 보여줍니다. 특히, 대규모 다중작업 언어 이해(MMLU) 벤치마크에서 인간 전문가의 점수를 능가하는 결과를 보여주기도 했다.

일상 비서 역할 강화

Gemini for Home은 구글 어시스턴트를 대체하는 새로운 AI 기반 생활 도우미로, 일상 루틴 관리, 더 자연스러운 대화 및 스마트홈 기기 제어 기능을 포함합니다. 2025년 10월부터 초기 액세스 제공 예정이다.
또한 Android Auto에도 Gemini가 통합되어, 운전 중 음성 명령으로 메시지 전송, 이메일 확인 등 다양한 기능을 수행할 수 있다.

Google Workspace 통합 및 다국어 대응

Gemini는 Gmail, Calendar, Maps, Photos, YouTube 등을 연결해 여러 앱 사이를 오가며 작업을 도와준다. 일정 관리, 알람 설정, 통화, 발표 연습 같은 기능도 제공돼된다.
현재 40개 이상의 언어를 지원하며, 모바일 앱(Android, iOS)과 웹을 통해 이용할 수 있다. 또한 Gemini 2.5 Flash와 2.5 Pro는 과금 기반의 유료 모델로도 제공된다.

활용 분야

Gemini는 다음과 같은 다양한 분야에서 활용될 수 있다.
- 창의적인 작업: 글쓰기, 이미지 생성, 아이디어 브레인스토밍 등
- 학습 및 연구: 복잡한 주제 요약, 논문 분석, 학습 계획 수립 등
- 코딩: 코드 생성, 디버깅, 최적화 등
- 고객 서비스: 질문에 대한 정확하고 유익한 답변 제공 등

Gemini는 Google AI Studio, Vertex AI 등 다양한 Google 클라우드 서비스와 연동되어 사용될 수 있으며, Google의 AI 어시스턴트인 Gemini에도 탑재되어 있다.

경쟁력 & 비교 포인트

구글은 Gemini가 OpenAI의 GPT‑4와 유사하거나 더 높은 벤치마크 성능을 낸다고 발표했지만, 실제 사용 경험은 용도에 따라 다를 수 있다.
Gemini는 특히 멀티모달 설계, 긴 컨텍스트 창, 강화된 이미지 및 음성 처리 능력에서 차별점을 보이고 있다.

요약

영역	특징 요약
멀티모달 처리	텍스트, 이미지, 오디오, 영상, 코드 모두 이해/생성 가능
모델 구성	Gemini 1.0 (Ultra/Pro/Nano) → 2.5 Flash / Pro 등 최신 버전
이미지 편집	Nano‑Banana: 자연어 기반 편집, 특징 일관성 유지
음성 인터페이스	Gemini Live: 음성 기반 실시간 대화
일상 비서 기능	Gemini for Home, Android Auto 음성 지원
Workspace 연동	Gmail, Calendar 등과 통합, 다양한 앱 연결 가능
경쟁력	GPT‑4 대비 멀티모달 설계, 긴 컨텍스트, 높은 벤치마크
과금 모델	무료 + 프리미엄 플랜 (예: Gemini 2.5 Pro 등)

향후 흐름

Gemini는 앞으로 스마트홈, 차량, 생산성 도구, 멀티미디어 생성 등 다양한 분야에 깊숙이 통합될 예정이며, 계속해서 새로운 기능 및 버전이 출시되고 있다.

Ollama

Sat, 30 Aug 2025 17:05:00 +0900

Ollama란?

Ollama는 최근 AI/LLM 개발자들 사이에서 많이 쓰이는 도구이다.

Ollama는 로컬 환경에서 대형 언어 모델(LLM)을 간편하게 실행하고 관리할 수 있게 해주는 오픈소스 플랫폼이다.
즉, OpenAI API 같은 클라우드 모델을 쓰지 않고도 내 PC(Mac/Linux/Windows) 에서 Llama·Mistral·Gemma·CodeLlama 같은 모델을 불러와 사용할 수 있게 해준다.

Ollama의 주요 특징

로컬 실행 지원
- 인터넷 연결 없이도 모델을 실행 가능
- 기업 보안이나 개인 프라이버시에 유리
간단한 모델 배포
- ollama run llama3 같은 명령어 한 줄로 모델 실행
- Docker처럼 모델 패키지 관리를 지원 (Modelfile이라는 설정 파일로 관리)
여러 모델 지원
- Meta LLaMA, Mistral, Gemma, Code Llama, Phi 등 다양한 모델 다운로드 및 실행 가능
API 제공
- REST API 형식으로 로컬 서버(http://localhost:11434/api/generate)를 열어서 다른 앱에서 호출 가능
- 즉, 로컬 OpenAI API 서버처럼 활용 가능
GPU 최적화
- MPS(Mac), CUDA(NVIDIA GPU) 지원 → 속도 빠름
- CPU에서도 실행 가능하지만 속도는 떨어짐

Ollama 사용

설치

macOS/Linux/Windows도 패키지 제공
- https://ollama.com/download
macOS
- brew install ollama

macOS 설치 완료 후 실행하면 메뉴 바에 ollama 아이콘 표시된다.

모델 실행

ollama run llama3

처음 실행하면 모델을 자동 다운로드 후 실행 (llama3 모델 용량 4.7GB)

모델 다운로드

공식 사이트에서 사용할 model 검색후 마음에 드는 모델 설치

추천 모델
- https://www.ollama.com/library/gpt-oss
  - chatgpt 수준의 채팅이나 분석, 업무등을 원한다면 사용. 맥북에서 조금 느리지만 동작은 잘 함
- https://www.ollama.com/library/phi4-mini
  - 단순 mcp server 호출 대상 탐색등의 간단한 작업에 어울림, tools 지원하는 경량 모델이면 어느것이어도 상관없음. qwen, deepseek는 사용 금지.

API 호출 (예: curl)

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

모델 관리

ollama list → 설치된 모델 확인
ollama pull mistral → 새로운 모델 다운로드
ollama create mymodel -f Modelfile → 커스텀 모델 생성

Ollama와 다른 LLM 실행 프레임워크 비교

도구	특징
Ollama	가장 간단한 설치/실행, 로컬 API 제공, 모델 패키지 관리
LM Studio	GUI 기반, 모델 선택과 실행 직관적
vLLM	고성능 서버 실행 최적화, 주로 대규모 배포에 사용
Text Generation WebUI	다양한 모델 실행 + Web UI 제공
OpenAI API	클라우드 기반, 최신 모델 사용 가능, 하지만 비용/프라이버시 이슈

활용 사례

개발 환경에서 로컬 AI 어시스턴트 구축
사내 보안 데이터와 연결한 내부 챗봇
LangChain, LlamaIndex 같은 프레임워크와 연동해 RAG 시스템 구축
프로토타이핑: OpenAI API 비용 안 쓰고 빠르게 실험

정리

Ollama는 로컬에서 쉽게 LLM을 실행할 수 있게 해주는 “Docker for LLMs” 같은 플랫폼이다. 개인 연구부터 기업용 챗봇까지 다양하게 쓸 수 있다.

MCP Server

Sat, 30 Aug 2025 14:55:00 +0900

MCP 서버란?

MCP 서버는 AI 모델이 외부 리소스(도구, 데이터, API 등)에 접근할 수 있도록 연결해주는 표준화된 인터페이스를 제공하는 역할을 한다.
쉽게 말하면, AI가 쓸 수 있는 도구 모음집을 제공하는 서버라고 할 수 있다.

구조

MCP는 크게 클라이언트(Client) 와 서버(Server) 로 나뉘는데:

MCP 클라이언트
- LLM 환경에 붙어 있는 애플리케이션 (예: IDE, Chat UI, Notebook 등)
- 사용자의 프롬프트를 받아 모델을 실행시키고, 필요하면 MCP 서버에 요청
MCP 서버
- 여러 리소스/도구/함수를 관리하고 제공
- 표준화된 프로토콜(JSON-RPC 기반)을 통해 클라이언트와 통신
- 예: DB 조회 서버, 파일 시스템 서버, API 호출 서버

서버가 제공하는 것

MCP 서버는 크게 네 가지 기능을 제공한다:

리소스(Resources)
- 데이터베이스, 파일, 문서, API 응답 등
- 예: resource://db/customers, resource://filesystem/project/README.md
도구(Tools)
- 호출 가능한 함수/액션
- 예: searchCustomer(name), sendEmail(to, subject, body)
프롬프트(Prompts)
- 미리 정의된 템플릿을 제공
- 예: “SQL 쿼리 생성용 프롬프트”
이벤트(Events)
- 서버에서 발생하는 알림이나 변경 이벤트를 실시간으로 전달

동작 흐름 예시

사용자가 IDE 안에서: “DB에서 고객 ‘홍길동’ 검색해줘” 입력
LLM이 판단 → MCP 클라이언트를 통해 “searchCustomer” 도구 호출 요청
MCP 클라이언트 → MCP 서버 요청 전달
MCP 서버가 실제 DB 조회 수행 후 결과 반환
결과를 LLM이 사용자 친화적 문장으로 정리해서 보여줌

MCP 서버 예시

예를 들어, 파일 시스템 MCP 서버라면:

Resource: 프로젝트 폴더 내 파일들 (/src/main.kt, /README.md)
Tools: 파일 읽기, 쓰기, 검색 기능 (readFile, writeFile)
Prompts: “이 코드를 리팩토링 해줘” 같은 템플릿

→ 이렇게 구성된 서버를 붙이면, AI는 프로젝트 파일을 직접 탐색/수정 가능해짐.

비유

MCP 서버 = “호텔 컨시어지”
- 손님(LLM)이 “관광지 추천해줘” 하면, 컨시어지가 여러 API/DB를 뒤에서 다뤄서 정리된 정보 제공
MCP 클라이언트 = “호텔 프런트”
- 손님과 직접 대화하며, 요청을 받아서 컨시어지에게 전달

정리

MCP 서버는 LLM이 외부 도구와 데이터를 안전하고 일관된 방식으로 활용할 수 있도록 표준화된 인터페이스를 제공하는 백엔드 역할을 한다.

GitHub Copilot

Sat, 30 Aug 2025 14:50:00 +0900

Copilot이란?

GitHub Copilot은 GitHub와 OpenAI가 공동 개발한 AI 기반 코드 자동 완성 도구이다.
개발자가 코드를 작성할 때, 주석이나 함수 시그니처, 맥락(Context) 을 분석하여 가장 적절한 코드를 자동으로 제안한다.
흔히 AI 페어 프로그래머(AI Pair Programmer) 라고 불린다.

주요 특징

자동 코드 제안
- 한 줄, 함수 전체, 심지어 테스트 코드까지 자동 생성
- 반복되는 패턴을 빠르게 채워줌
주석 기반 개발
- // 두 숫자를 더하는 함수 작성 같은 자연어 주석을 입력하면 코드를 생성
맥락 이해
- 현재 파일, 프로젝트 내 다른 파일들을 참고해 더 자연스러운 제안 가능
다양한 언어/프레임워크 지원
- Python, JavaScript, TypeScript, Go, Java, C#, C++ 등 광범위한 언어 지원
IDE 통합
- VS Code, JetBrains IDE, Neovim 등 주요 개발 환경에 플러그인으로 제공

활용 사례

반복 작업 단축: boilerplate 코드, CRUD API, 테스트 코드 작성
신규 언어 학습: 생소한 언어/프레임워크 문법을 빠르게 습득
알고리즘 구현: 주석으로 요구사항 작성 후 코드 자동 생성
리팩터링 보조: 더 나은 구현 방식 제안

장점

개발 속도 향상: 일상적인 반복 코딩을 크게 줄여줌
학습 효과: 모르는 API나 문법을 예시로 보여줌
코드 일관성 유지: 팀 규칙에 맞게 보일러플레이트 자동화
테스트 작성 보조: TDD 사이클 가속화

한계/단점

정확성 불완전: 항상 올바른/최적의 코드가 나오지 않음
보안 위험: 취약점 포함 가능 (예: SQL 인젝션 방어 누락)
라이선스 문제: 공개 코드에서 학습했기에 일부 코드가 저작권 이슈 될 수 있음
맥락 제한: 프로젝트 전체를 깊게 이해하기엔 한계 있음

비용

유료 구독제 (2025년 현재 기준)
- 개인: 월 약 $10 (USD)
- 기업: 월 약 $19 (USD) / 사용자
학생/오픈소스 기여자는 무료 제공

Copilot과 바이브 코딩의 차이

Copilot: 개발자가 주도, AI는 제안 (보조 도구)
바이브 코딩: AI가 주도, 개발자는 목표와 피드백만 (창작 스타일)

비슷한 AI 코딩 도구

Amazon CodeWhisperer (AWS)
Tabnine
Cursor IDE (ChatGPT 내장 IDE)
Replit Ghostwriter

정리

GitHub Copilot은 “AI 페어 프로그래머"로, 주석·코드 맥락을 기반으로 실시간 코드 제안을 해주는 도구이다.
반복적이고 생산성 낮은 작업을 줄여주고, 초안 코드를 빨리 만들 수 있지만, 반드시 검증·리뷰·테스트가 필요하다.

Function Calling (Tools)

Sat, 30 Aug 2025 14:50:00 +0900

Function Calling (도구 호출) 이란?

LLM이 단순히 텍스트만 생성하는 게 아니라, 외부 함수(Function)나 API를 직접 호출할 수 있도록 하는 기능이다.
예를 들어, OpenAI API에서 제공하는 function_call 기능이 대표적이다.

동작 원리

사용자 입력: “오늘 서울 날씨 알려줘”
LLM 판단: “이건 날씨 API를 호출해야 하는구나”
도구 호출: 미리 정의된 함수(예: getWeather(location: string)) 실행
결과 수신: { "location": "Seoul", "temp": 28, "condition": "Sunny" }
최종 응답 생성: “오늘 서울은 맑고 28도입니다 ☀️”

즉, LLM은 자연어 → 함수 입력 변환 역할을 하고, 실제 계산·검색은 외부 함수/도구가 맡는다.

장점

실시간 데이터 활용
- LLM 자체는 훈련 시점 이후 지식을 모름. Function Call로 최신 API 연결 가능.
정확한 계산
- LLM은 수학 연산에 약함. 대신 계산기 API를 호출하면 정확한 결과 반환.
업무 자동화
- “메일 보내줘” → 이메일 API 호출
- “DB에서 고객 목록 가져와” → DB 쿼리 실행

MCP와 Function Calling의 차이

Function Calling
- 개별 도구를 LLM이 직접 호출하는 방식
- API나 함수 단위의 호출 정의 필요
- 예: getWeather(), searchStockPrice()
MCP (Model Context Protocol)
- 여러 도구(Function/Resource)를 표준화된 방식으로 연결하는 프로토콜
- 각 도구를 “Provider"로 추상화하여, LLM이 일관된 방법으로 접근 가능
- Function Call을 포함해서 “도구 호출"을 체계적으로 관리하는 상위 개념

실제 예시

1. Function Calling 단독 사용

OpenAI Function Call 예제:

{
  "name": "getWeather",
  "description": "현재 날씨 조회",
  "parameters": {
    "type": "object",
    "properties": {
      "location": { "type": "string" }
    },
    "required": ["location"]
  }
}

👉 모델이 "서울"을 location에 매핑해 API 실행

2. MCP 기반 Function Calling

MCP는 Function들을 Resource Registry로 묶어 관리
LLM이 “날씨 API"를 직접 알 필요 없이, MCP가 추상화된 tools.weather 같은 인터페이스 제공
여러 도구를 표준 프로토콜로 연결 → Function Call 혼란/중복 줄여줌

비유로 정리

Function Calling = 개별 “도구 사용법” (드라이버: 가위, 망치, 드라이버 같은 단일 도구)
MCP = “공구함/작업대” (도구를 표준화된 방식으로 정리해 둔 시스템)

정리

Function Calling은 개별 API를 호출하는 기술이고, MCP는 여러 Function(도구)들을 표준화된 방식으로 관리하고 연결해주는 상위 레이어라고 이해하면 된다.

AI Agent

Sat, 30 Aug 2025 13:49:00 +0900

AI Agent란?

AI Agent는 단순히 답변만 생성하는 LLM(대규모 언어모델)과 달리, 환경(Environment)과 상호작용하며 특정 목표를 달성하도록 설계된 지능형 시스템이다.
즉, 스스로 판단하고 → 필요한 도구를 쓰고 → 행동하며 → 결과를 개선하는 AI라고 할 수 있다.

AI Agent의 핵심 요소

목표(Goal)
- 에이전트가 수행해야 할 임무. (예: 고객 질문 답변, 보고서 작성, 코드 수정 등)
지각(Perception)
- 환경이나 입력을 이해하는 단계. (사용자 입력, 센서 데이터, API 응답 등)
행동(Action)
- 목표를 달성하기 위해 취하는 조치. (검색, 계산, 외부 API 호출, DB 업데이트 등)
피드백 루프(Feedback Loop)
- 결과를 평가하고 필요 시 다음 행동을 수정하는 과정.

AI Agent와 단순 LLM의 차이

LLM: 질문 → 답변 (단순 Q&A)
AI Agent: 질문 → 계획 세움 → 검색/도구 사용 → 여러 단계 실행 → 최종 답변

예를 들어,

LLM은 “서울 날씨 알려줘"에 대해 과거 학습 데이터를 기반으로 답할 수 있지만,
AI Agent는 실시간 API를 호출해 현재 기온과 날씨를 가져와 답할 수 있다.

AI Agent가 사용하는 기술

LLM (Large Language Model) → 자연어 이해 및 추론
RAG (Retrieval-Augmented Generation) → 외부 지식 검색
도구 사용(Plugins, APIs) → 계산기, 브라우저, 데이터베이스 등
플래너(Planner) → 복잡한 작업을 여러 단계로 쪼개어 실행
메모리(Memory) → 과거 대화/상태를 기억하여 연속적인 작업 수행

대표적인 AI Agent 예시

ChatGPT + Tools (OpenAI) → 코드 실행, 웹 브라우징, 데이터 분석 가능
AutoGPT, BabyAGI → 오픈소스 자율형 에이전트
LangChain Agents → 여러 툴을 연결해 워크플로우 자동화
Microsoft Copilot, Google Gemini Agents → 생산성 툴과 통합된 AI 비서

AI Agent의 활용 분야

업무 자동화: 이메일 요약, 일정 관리, 문서 생성
고객 지원: FAQ 답변, 상담 업무 보조
연구·분석: 논문 검색, 데이터 분석, 보고서 작성
개발 보조: 코드 생성, 테스트, 디버깅
로보틱스: 자율주행, 드론, 스마트 팩토리

정리

AI Agent는 단순히 답변만 하는 LLM을 넘어, 목표를 세우고 도구를 활용하며 환경과 상호작용하는 지능형 시스템이다.
즉, “실행 가능한 AI“라고 이해하면 된다.

Multi-Model

Sat, 30 Aug 2025 13:14:00 +0900

Multi-Model이란?

하나의 AI 시스템에서 여러 개의 모델을 함께 사용하는 접근 방식을 말한다.
즉, 단일 모델에 모든 걸 맡기지 않고, 각 모델의 강점을 조합해서 더 나은 성능이나 다양한 기능을 얻는 방법이다.

예들 들어, 텍스트뿐 아니라 이미지, 오디오, 비디오까지 함께 처리할 수 있는 모델이다.

왜 필요한가?

한 모델로는 부족한 경우
- 예: 이미지도 다루고 텍스트도 다뤄야 하는 경우
전문화된 모델 활용
- 대규모 범용 모델 + 도메인 특화 모델을 같이 사용
성능 최적화
- 무겁고 느린 모델은 핵심 추론에만, 가벼운 모델은 전처리·간단한 작업에 사용
비용 절감
- 항상 GPT-4 같은 초거대 모델을 쓰면 비쌈 → 일부는 작은 모델에게 맡기고, 어려운 부분만 큰 모델 사용

Multi-Model의 종류

멀티 모달(Multi-Modal)과는 다름
- Multi-Model ≠ Multi-Modal
- Multi-Modal: 이미지+텍스트+음성 등 여러 입력 형태를 처리하는 하나의 모델
- Multi-Model: 여러 개의 모델을 조합해서 시스템 구성
구성 방식
- 병렬(Ensemble): 여러 모델이 동시에 답을 내고, 결과를 합쳐서 최종 결정
  - 예: 투표(Voting), 평균(Blending), 가중치 조합(Weighted Sum)
- 직렬(Pipeline): 한 모델의 출력을 다른 모델의 입력으로 전달
  - 예: 이미지 캡션 모델 → 텍스트 요약 모델 → 질의응답 모델
- 하이브리드: 상황에 따라 모델 선택 (Router 모델)

예시

검색 + 생성 (RAG)
- 검색 모델(벡터 검색) + 생성 모델(LLM)
Copilot류
- 코드 보조: 빠른 코드 완성은 작은 모델, 정교한 버그 수정은 GPT-4
자율주행
- 영상 인식 CNN + 행동 계획 RL 모델
헬스케어
- 의학적 지식 모델 + 일반 LLM 조합

Multi-Model vs Single Model

구분	Single Model	Multi-Model
구성	하나의 모델이 모든 걸 수행	여러 모델이 역할 분담
장점	단순, 관리 쉬움	정확도↑, 유연성↑, 최신 기술 활용 가능
단점	범용 모델은 성능 한계	시스템 복잡, 조율 필요

정리

Multi-Model은 여러 모델을 결합해, 각자의 장점을 살려 더 나은 결과를 내는 시스템 설계 방식이다.

예: “검색 모델 + 생성 모델”, “작은 모델 + 큰 모델”, “특화 모델 + 범용 모델"을 조합하는 식이다.

RAG(Retrieval-Augmented Generation)

Sat, 30 Aug 2025 13:09:00 +0900

RAG (Retrieval-Augmented Generation) 개념

RAG = 검색(Retrieval) + 생성(Generation)
LLM(대규모 언어모델)이 자기 내부 지식만으로 답을 생성하는 것이 아니라, 외부 데이터베이스(예: 문서, 벡터 DB, 위키, 사내 자료 등)에서 관련 정보를 검색한 후, 그 결과를 바탕으로 답변을 생성한다.

즉, 단순히 “모델이 아는 것"만 쓰는 게 아니라, “필요할 때 외부에서 찾아보고 답하는” 똑똑한 비서 같은 개념이다

왜 필요한가?

LLM의 지식 한계 극복
- LLM은 학습 시점 이후의 최신 정보를 알지 못한다.
- 예를 들어, GPT 같은 모델은 학습 시점 이후의 최신 정보는 모른다.
- RAG를 사용하면 DB/웹에서 찾아온 자료를 활용 가능하게 된다.
환각(Hallucination) 줄이기
- LLM은 모르는 것도 지어낼 때가 있다.
- 외부 근거 자료를 활용하면 답변 신뢰도를 높일 수 있다.
- 근거 없는 답변 대신, 실제 문서/DB를 근거로 답변 가능하다.
맞춤형 지식 활용
- 기업 내부 문서, 보고서, 고객 FAQ, 논문, 코드베이스 등의 전용 데이터를 LLM이 사용할 수 있음.
- 사내 비밀 문서를 학습시키지 않고도 활용 가능하다.

RAG의 동작 구조

질의(Query) 입력
- 사용자가 질문을 입력한다.
검색(Retrieval) 단계
- 질문을 벡터화(임베딩) 후, 벡터 데이터베이스에서 관련 문서를 검색한다.
- 대표 DB: Pinecone, Weaviate, Milvus, FAISS 등.
생성(Generation) 단계
- LLM이 검색된 문서를 참고하여 답변을 생성하여 함께 전달한다.

즉, “찾아서 → 참고해서 → 답변하는” 구조이다.

예시

예를 들어, “우리 회사의 2023년 매출은 얼마야?“라는 질문이 들어오면:

LLM 단독: “2023년 매출은 1억 달러입니다.” (근거 없음, 틀릴 수 있음)
RAG 활용: 회사 내부 재무 보고서를 검색 → 관련 데이터 가져옴 → “2023년 당사의 매출은 9,200억 원으로, 전년 대비 8% 성장했습니다.” (근거 있는 답변)

비유로 이해하기

LLM 단독: 기억력 좋은 사람, 하지만 최신 정보는 모를 수 있다.
RAG 사용: 기억력 좋은 사람이 사전·검색 엔진을 참고해서 답변하는 것이다.

RAG와 Fine-tuning의 비교

Fine-tuning: 모델 자체를 추가 학습 → 새로운 지식을 “내재화”
RAG: 모델은 그대로 두고, 외부 자료를 검색해서 활용

방법	장점	단점
Fine-tuning	응답이 빠르고 자연스러움	데이터 업데이트할 때마다 재학습 필요
RAG	항상 최신/맞춤 정보 반영 가능, 빠른 구축	검색 품질에 따라 답변 품질 좌우

실무에서는 RAG + 필요시 일부 Fine-tuning을 섞어서 많이 사용된다.

RAG 구현에 쓰이는 기술 스택

임베딩 모델: OpenAI Embeddings, Sentence-BERT 등
벡터 DB: Pinecone, Weaviate, Milvus, FAISS
LLM: GPT, Claude, LLaMA, Gemini 등
프레임워크: LangChain, LlamaIndex, Haystack

정리

RAG는 LLM이 검색 시스템을 함께 사용해, 신뢰할 수 있고 최신 정보를 반영하는 답변을 생성하는 방식이다.
즉, 지식의 확장 & 신뢰성 보강을 위한 핵심 기술이다.

LLM(Large Language Model)

Sun, 24 Aug 2025 13:14:00 +0900

LLM 개요

LLM(Large Language Models, 대규모 언어 모델)은 방대한 양의 텍스트 데이터를 학습하여 자연어를 이해하고 생성할 수 있는 인공지능 모델이다. 이들은 주로 딥러닝 기반의 트랜스포머 구조를 활용하는데, 따라서 인간의 언어 특성을 통계적으로 파악하여 높은 수준의 텍스트 생성 및 처리 능력을 갖추고 있다.

LLM은 오늘날 AI의 중추로서, 언어 기반 애플리케이션과 시스템 설계에서 매우 중요한 역할을 수행하고 있다.

LLM 작동 원리

학습 방식 및 트랜스포머 아키텍처

LLM은 수천억 개의 텍스트 예시를 통해 비지도 학습 방식으로 사전 학습(pre-training)을 수행한다.
특히, 트랜스포머 구조는 셀프 어텐션(self-attention)을 통해 문맥의 관계를 이해하며, 이전의 순환신경망(RNN)보다 병렬 처리가 가능하여 학습 효율이 매우 높다

파라미터와 임베딩

‘대규모’라는 명칭은 수십억에서 수천억 개에 이르는 “파라미터(parameter)“의 크기를 의미한다. 이러한 방대한 매개변수를 통해 언어의 복잡한 맥락과 뉘앙스를 포착할 수 있다. 또한, “임베딩(embedding)“은 단어를 다차원 벡터로 변환하여 의미적 유사성을 수치적으로 표현함으로써 문맥 이해를 돕는다.

응용 분야

LLM은 매우 유연하게 활용될 수 있으며, 대표적인 응용 예시는 다음과 같다:

생성형 AI: 사용자 프롬프트에 따라 에세이, 번역, 요약 등의 텍스트 생성
코드 생성: GitHub Copilot, AWS CodeWhisperer 등 자연어로부터 코드 작성 지원
텍스트 분류 및 감정 분석: 고객 피드백 분류, 문서 클러스터링 등
기타: 지식 기반 질의 응답(KI-NLP), 챗봇, 고객 서비스 자동화 등

학습 방법의 종류

LLM을 특정 용도에 맞추어 활용하는 방법에는 다음 세 가지가 있다:

제로샷 학습 (Zero-Shot): 추가 학습 없이 일반적인 프롬프트만으로 다양한 작업 수행 가능
퓨샷 학습 (Few-Shot): 소량의 예제를 제공함으로써 성능을 향상
미세 조정 (Fine-Tuning): 특정 데이터로 파라미터를 추가 학습시켜 특화된 적용이 가능

중요성 및 기대 효과

LLM의 도입은 기업과 조직에 다양한 이점을 가져다줄 수 있다:

업무 자동화: 고객 지원, 문서 요약, 콘텐츠 생성 등 언어 기반 작업의 자동화로 생산성 향상
확장성 및 유연성: 하나의 모델이 번역, 요약, 질의 응답 등 여러 작업에 유연하게 대응
혁신 유도: 지식 추출, 창작 보조, 대화형 인터페이스 등 다양한 미래 가능성에 기반 제공

한계 및 고려 사항

LLM 활용 시에는 다음과 같은 한계도 고려해야 한다:

높은 자원 요구: 수십억 개 파라미터 기반 모델의 학습 및 서비스 운영에는 상당한 컴퓨팅 자원이 필요하다.
잠재적 편향 및 오류: 학습 데이터의 한계 또는 편향이 모델 출력에 반영될 수 있으며, 정확성에 대한 지속적인 개선이 필요하다.
프라이버시 및 보안 우려: 사적이거나 민감한 데이터와의 연관 가능성에 대비해야 한다.

요약

항목	설명
정의	방대한 텍스트 기반 딥러닝 모델로 자연어 이해·생성 가능
작동 원리	트랜스포머 기반, 셀프 어텐션·임베딩·수십억 파라미터
응용 분야	텍스트 생성, 코드 생성, 분류, 요약, 챗봇 등
학습 방식	Zero-Shot, Few-Shot, Fine-Tuning
장점	자동화, 확장성, 창의적 활용 가능성
한계	자원 요구, 편향·정확도 문제, 보안 위험 등

MCP (Model Context Protocol)

Sun, 24 Aug 2025 13:14:00 +0900

MCP 개요

Model Context Protocol(MCP)는 AI, 특히 대규모 언어 모델(LLM)이 외부 데이터 소스 및 도구와 효과적으로 상호작용하도록 돕는 오픈 표준 프로토콜이다.

이 프로토콜은 애플리케이션이 LLM에 컨텍스트(Context)를 일관된 방식으로 전달할 수 있도록 설계되었다. 한마디로, AI용 USB-C 포트라는 은유로 설명되기도 한다. 이는 USB-C가 여러 장치를 통일된 포맷으로 연결하듯, MCP도 AI 모델과 다양한 리소스를 표준화된 방식으로 연결해 준다.

즉, AI 모델이 다양한 외부 시스템과 연결될 수 있도록 해주는 공용 인터페이스이다.

주요 특징

표준화된 인터페이스
- 모델이 “데이터 소스 / 도구 / 애플리케이션"에 접근할 수 있는 공용 규약 제공.
플러그형 구조
- 특정 애플리케이션에 종속되지 않고, 어떤 모델이든 MCP를 지원하면 같은 방식으로 확장 가능.
보안 & 제어
- 모델이 접근할 수 있는 범위를 제한하고, 사용자가 허용한 리소스에만 접근하도록 설계.
개발자 친화적
- OpenAI, Anthropic 같은 여러 AI 모델에서 공용으로 사용 가능 → “한번 만든 MCP 도구는 어디서든 사용”.

예시

모델이 “데이터베이스 질의"가 필요할 때:
```
모델 → MCP → DB Adapter → Database
```

모델이 “웹 API 호출"을 해야 할 때:

모델 → MCP → HTTP Adapter → 외부 REST API

즉, MCP는 AI의 플러그인 생태계를 표준화하는 기반 기술이라고 볼 수 있다.

도입 배경과 필요성

AI 모델은 본질적으로 텍스트 기반으로만 입출력을 한다. 그러나 실제 활용에서는 DB 조회, API 호출, 파일 입출력 등 다양한 작업이 필요하다. 지금까지는 플러그인, LangChain, 자체 API 브릿지 같은 개별 솔루션을 써야 했는데, 이들을 표준화된 프로토콜로 묶은 것이 MCP이다.

기존에는 AI 애플리케이션이 외부 시스템과 상호작용하기 위해, 모델마다, 도구마다 각각 맞춤형 통합 구현이 필요했다. 이로 인해 개발 및 유지보수의 복잡성이 크게 증가했고, 이를 M×N 문제라고 표현했다. MCP는 이를 M＋N 구조로 단순화하여, AI 애플리케이션이 다양한 도구와 표준화된 방식으로 연결될 수 있도록 지원한다.

이미지 출처: https://www.descope.com/learn/post/mcp

아키텍처 및 작동 원리

클라이언트-서버 구조

MCP는 클라이언트-서버 아키텍처를 채택하고 있으며,

MCP 클라이언트는 AI 애플리케이션(예: Claude Desktop)이다.
MCP 서버는 파일 시스템, 데이터베이스, API 등 외부 리소스를 제공한다.

통신 방식

MCP는 JSON-RPC 2.0 기반으로 요청(Request)과 응답(Response)을 교환하며, 이는 표준화된 메시지 교환 방식을 통해 상호운용성을 향상시킨다. 또한, **로컬 프로세스 간 통신(stdio 기반)**과 HTTP + SSE(서버 전송 이벤트) 기반 통신을 모두 지원한다.

서버의 역할

MCP 서버는 다음과 같은 기능을 수행한다.

Tool Registry: 사용 가능한 툴 및 기능의 목록 관리
Authentication: 접근 권한 검증
Request Handler: 클라이언트의 요청 처리
Response Formatter: 결과를 AI 모델이 이해할 수 있는 형식으로 가공

AI 애플리케이션은 서버에 “사용 가능한 도구 목록"을 요청하고, 이를 바탕으로 적절한 툴을 선택하고 활용할 수 있다.

개발자 친화성과 확장성

Anthropic은 MCP를 오픈소스 표준으로 공개하였으며, Python, TypeScript, Java, Kotlin, C# 등 주요 언어용 SDK도 제공하고 있다. 이를 통해 클라이언트 및 서버 구현이 대체로 간단하다는 장점을 얻을 수 있다

활용 효과 및 이점

명확한 지시: LLM이 어떤 데이터를 취급할지 명확히 지정 가능
불명확성 제거: 여러 정보원을 명확히 구분하여 참조 가능
특화된 처리 지원 가능: 특정 데이터 형식에 맞춘 전용 처리가 가능
컨텍스트 예시: 파일 시스템, DB, 클라우드 서비스 등 다양한 컨텍스트를 함께 활용 가능

이러한 이점 덕분에, AI의 활동 범위가 확장되고, 더 정확하고 문맥에 맞는 응답을 제공할 수 있게 된다.

도입 시기 및 생태계 동향

MCP는 2024년 11월에 Anthropic이 오픈소스로 공개하였으며, 2025년 초부터 개발자 커뮤니티와 주요 AI 도구들에서의 채택이 급속히 증가하였다.
C#용 공식 SDK의 출시에 관한 언급도 있으며, 현재 수많은 MCP 서버가 운영 중이며, 보안 아키텍처 및 데이터 보호도 중요한 관심사로 자리 잡고 있다.

요약 표

항목	설명
정의	AI 모델과 외부 데이터/도구를 연결하는 오픈 표준 프로토콜
도입 배경	개별 통합의 복잡성을 해소하고 더 유연한 확장성 확보
구조	클라이언트-서버 구조, JSON-RPC, 표준 메시지 교환
SDK	Python, TS, Java, Kotlin, C# 등 제공
이점	명확성, 확장성, 자동화, 보안성 강화 등
현재 동향	공개 이후 급성장 중이며 보안 및 실용성 확대 중

궁금하신 부분이 더 있다면 언제든지 말씀해 주세요. 예를 들어, MCP 서버 직접 구축 사례나 기술 활용 흐름 등도 설명드릴 수 있습니다.

SRE란?

Sun, 24 Aug 2025 13:07:00 +0900

SRE란?

SRE(Site Reliability Engineering, 사이트 신뢰성 엔지니어링)은 IT 운영에 대한 소프트웨어 엔지니어링 접근 방식이다. SRE은 소프트웨어를 툴로 활용하여 시스템을 관리하고, 문제를 해결하고, 운영 태스크를 자동화한다.

SRE는 확장 가능하고 신뢰성이 높은 소프트웨어 시스템을 생성할 때 유용한 방법이다. 코드를 통해 대규모로 시스템을 관리할 수 있으므로 수천 대에서 수십만 대에 이르는 머신을 관리하는 시스템 관리자에게 더 큰 확장성과 지속가능성을 제공한다.

Google 엔지니어링 팀의 Gen Treynor Sloss가 창안한 개념이다.

SRE를 사용함으로써 있는 장점

새 기능을 적시에 출시하고, 사용자가 이 기능을 안정적으로 사용하도록 할 수 있다.

SRE 엔지니어의 역할

부가적인 운영 경험이 있는 소프트웨어 개발자, 소프트웨어 개발 기술을 갖춘 시스템 관리자 또는 IT 운영자와 같은 경력이 요구되는 독특한 역할이다.

SRE팀은 코드의 배포, 설정, 모니터링 방식뿐만 아니라 프로덕션 환경에서 서비스 가용성, 대기 시간, 변경 관리, 비상 대응 및 용량 관리를 담당한다.

새로 출시할 기능과, 서비스 수준 계약(SLA)를 사용하여 서비스 수준 지표(SLI) 및 서비스 수준 목표(SLO)를 통해 시스템의 신뢰성 요구 사항을 정의해야 할 시점을 결정할 수 있다.

SRE에서는 100% 신뢰성을 기대하지 않으며 장애에 대비해 계획을 마련한다.

DevOps와 차이점

DevOps는 신속한 고품질 서비스 제공을 통해 비즈니스 가치와 대응력을 향상시키기 위한 기업 문화, 자동화, 플랫폼 설계에 대한 접근 방식이다.

SRE는 DevOps의 구현으로 간주될 수 있다.

	SRE	DevOps
주요 관심	확장성, 운영 지표, 자동화	개발 배포 과정 통합
담당자	운영에 관심있는 개발팀	개발에 관심있는 운영팀
측정 지표	서비스 수준 목표(SLO)의 최대/최소치	주로 시스템 Telemetry
적용 기업	클라우드-네이티브 환경에서 IT 서비스 기업	온-프레미스에서 클라우드로 전향하는 기업

TypeScript 얕은 복사와 깊은 복사

Sat, 16 Aug 2025 23:26:00 +0900

복사 (Copying)

프로그래밍에서 복사에는 크게 두 가지 방식이 있다.

깊은 복사(Deep Copy)
얕은 복사(Shallow Copy)

깊은 복사 (Deep Copy)

깊은 복사는 복사한 값이 바뀌더라도 원본 값은 영향을 받지 않는 복사 방식이다
TypeScript에서는 **원시 타입(primitive type)**인 number, boolean은 기본적으로 깊은 복사 방식으로 동작한다.

let original = 1;
let copied = original;
copied += 2;

console.log(original, copied); // 1 3

원본 original은 변하지 않고, copied만 변경된다.

얕은 복사 (Shallow Copy)

얕은 복사는 복사본과 원본이 같은 참조(reference)를 공유하는 복사 방식이다.
TypeScript에서 **객체(Object)와 배열(Array)**는 기본적으로 얕은 복사 방식으로 동작한다.

const originalArray = [5, 3, 9, 7];
const shallowCopiedArray = originalArray;

shallowCopiedArray[0] = 0;

console.log(originalArray, shallowCopiedArray); 
// [0, 3, 9, 7] [0, 3, 9, 7]

배열 originalArray가 shallowCopiedArray와 같은 참조를 공유하기 때문에, 하나를 수정하면 다른 하나도 영향을 받는다.

전개 연산자(…)를 활용한 복사

**전개 연산자(...)**를 사용하면 1차원 배열에 한해 깊은 복사처럼 사용할 수 있다.

const oArray = [1, 2, 3, 4];
const deepCopiedArray = [...oArray];

deepCopiedArray[0] = 0;

console.log(oArray, deepCopiedArray); 
// [1, 2, 3, 4] [0, 2, 3, 4]

원본 배열은 그대로 유지되고, 복사본만 변경된다.

주의: 객체가 중첩된 배열이나 중첩 객체까지 완전히 복사하려면 전개 연산자만으로는 깊은 복사가 되지 않다.
이 경우 JSON.parse(JSON.stringify(obj)) 등을 사용한다.

정리

타입/방법	복사 방식	특징
number, boolean	깊은 복사	원본과 복사본 독립
객체(Object), 배열(Arra)	얕은 복사	원본과 복사본 참조 공유
전개 연산자 `...`	1차원 깊은 복사	1차원 배열/객체에 대해 원본 보존

인공지능 이해와 활용

Sat, 16 Aug 2025 22:33:00 +0900

서문

인공지능(AI: Artificial Intelligence)은 더 이상 미래의 기술이 아니라 현재 우리의 삶 속에 깊이 들어와 있는 핵심 기술이다. 여기서는 인공지능의 기본 개념에서부터 최신 응용 사례까지를 체계적으로 설명하여, 독자들이 AI의 본질을 이해하고 실제로 활용할 수 있도록 돕는 것을 목표로 한다.

AI 용어

Sat, 16 Aug 2025 22:33:00 +0900

헷갈리고 어려운 AI 관련 최근 용어들

AI(Artificial Intelligence)
- 컴퓨터가 사람의 지능을 모방하여 학습하고 문제를 해결하는 기술
ML(Machine Learning)
- AI가 데이터를 통해 자동 학습하고 예측하는 기술
DL(Deep Learning)
- ML의 한 종류로 ‘인공신경망’을 활용해 복잡한 패턴을 학습하는 기술
AX(AI Transformation)
- DX를 넘어 AI를 중심으로 기업의 변화를 추구
AGI(Artificial General Intelligence)
- 특정 작업에 국한되지 않고, 사람처럼 여러 분야에서 지능적으로 문제를 해결할 수 있는 인공지능
Gen(Generative) AI
- Text, Image, Music, Video 등을 생성하는 인공지능
Prompting
- Gen AI에게 필요한 답을 얻도록, 질문하는 방법
LLM(Large Language Model)
- 빅데이터를 기반으로 언어와 유사한 텍스트를 이해하고 만들어 내는 기술
FM(Foundation Model)
- 다양하고 방대한 양의 데이터로 사전 학습된 모델 (언어 처리, 이미지 인식, Audio/Video 생성 등에 기초 모델로 사용)
Hallucination(환각현상)
- AI가 잘못된 결론에 도달하여, 현실에 없는 결과물(콘텐츠)를 생성해 내는 현상

AI 도구

Sat, 16 Aug 2025 22:33:00 +0900

AI 도구

인공지능의 개념과 역사

Sat, 16 Aug 2025 22:33:00 +0900

인공지능의 정의

인공지능은 인간의 학습, 추론, 문제 해결 능력을 컴퓨터가 수행할 수 있도록 구현한 기술을 의미한다. 단순한 규칙 기반의 자동화에서 출발하여, 현재는 스스로 학습하고 적응하는 기계학습 및 딥러닝 기술로 발전하였다.

사례: 마트폰 음성 비서(예: Siri, Google Assistant)는 단순 명령 수행을 넘어 사용자의 언어 패턴을 학습하여 점차 정교한 대화를 지원한다.

인공지능의 역사

1950년대: 앨런 튜링의 “튜링 테스트” 제안
1960~70년대: 규칙 기반 전문가 시스템 등장
1980~90년대: 신경망 연구 재개 및 머신러닝 발전
2000년대 이후: 빅데이터와 GPU의 발전으로 딥러닝이 급성장
현재: 자연어 처리, 자율주행, 의료 진단 등 다양한 분야로 확산

도표 1: 인공지능 역사 연대표 (연도별 주요 기술 발전 흐름)
이미지 출처: https://spri.kr/posts/view/21643?code=industry_trend

인공지능의 핵심 기술

Sat, 16 Aug 2025 22:33:00 +0900

머신러닝

머신러닝(ML, Machine Learning)은 컴퓨터가 명시적으로 프로그래밍되지 않아도, 데이터에서 패턴을 학습하고 예측이나 결정을 내릴 수 있는 기술이다. 즉, 사람이 일일이 규칙을 작성하지 않아도, 데이터를 통해 스스로 규칙과 연관성을 찾아내는 능력을 말한다. 대표적으로 지도학습, 비지도학습, 강화학습이 있다.

머신러닝의 종류

머신러닝은 주로 학습 방식에 따라 세 가지로 나눈다.

지도학습(Supervised Learning)
- 정의: 입력 데이터와 그에 대응하는 정답(Label)을 함께 제공하여 모델을 학습시킨다.
- 목적: 입력 데이터로부터 정답을 예측
- 예시:
  - 이메일 스팸 분류 (스팸/정상)
  - 집 가격 예측 (면적, 위치 → 가격)
- 알고리즘: 선형회귀, 로지스틱 회귀, 결정트리, 랜덤포레스트, 서포트 벡터 머신 등
비지도학습(Unsupervised Learning)
- 정의: 정답 없이 입력 데이터만으로 학습하여 숨겨진 패턴이나 구조를 찾습니다.
- 목적: 데이터 군집화, 차원 축소
- 예시:
  - 고객 세분화 (구매 패턴 기반 군집)
  - 이상치 탐지 (사기 거래 발견)
- 알고리즘: K-평균 클러스터링, 계층적 군집화, PCA(주성분 분석) 등
강화학습(Reinforcement Learning)
- 정의: 행동에 따른 보상(Reward)과 벌점(Penalty)을 이용해 최적의 전략을 학습한다.
- 목적: 순차적 의사결정 최적화
- 예시:
  - 알파고 바둑
  - 자율주행 자동차 경로 학습
- 알고리즘: Q-러닝, 딥 Q-네트워크(DQN), 정책 경사법 등

머신러닝의 작동 원리

데이터 수집: 학습할 데이터를 모음 (예: 이미지, 텍스트, 센서 데이터)
데이터 전처리: 결측치 제거, 정규화, 특징(Feature) 추출
모델 선택: 문제 유형에 맞는 ML 알고리즘 선택
학습(Training): 데이터를 통해 모델이 규칙/패턴을 학습
평가(Evaluation): 테스트 데이터를 통해 모델 정확도 측정
예측(Prediction): 새로운 데이터에 대한 결과를 예측

머신러닝의 실제 사례

의료: MRI, CT 영상 분석을 통한 질병 진단 보조
금융: 신용 점수 예측, 사기 거래 탐지
전자상거래: 개인 맞춤형 상품 추천
자율주행: 도로 객체 인식, 경로 결정
자연어 처리: 기계 번역, 챗봇 대화 생성

머신러닝의 장점

데이터 기반 의사결정 가능
대규모 데이터 처리와 복잡한 패턴 학습에 효율적
반복 학습으로 성능 개선 가능

머신러닝의 한계

데이터 의존성: 품질 좋은 데이터가 반드시 필요
과적합(Overfitting): 학습 데이터에만 특화되어 일반화 능력 부족
설명력 부족: 모델이 왜 그런 결정을 내렸는지 이해하기 어려운 경우가 있음
윤리 문제: 편향된 데이터로 인해 불공정한 결과가 발생할 수 있음

딥러닝

딥러닝(Deep Learning)은 인공지능 분야에서 인간의 뇌 구조를 모방한 인공신경망(Artificial Neural Network)을 기반으로, 다층 구조를 통해 데이터의 복잡한 패턴과 특징을 학습하는 기술을 의미한다. 단순한 머신러닝 모델이 데이터의 기본적 관계를 학습하는 것에 비해, 딥러닝은 여러 층(Layer)을 거치며 점점 추상화된 특징을 학습함으로써 고차원적 문제 해결에 강점을 가진다. 이미지 인식, 음성 인식, 자연어 처리 등에서 탁월한 성능을 보여주고 있다.

딥러닝의 핵심 원리

인공신경망 구조
- 입력층(Input Layer): 데이터가 처음 들어오는 층
- 은닉층(Hidden Layer): 입력 데이터를 처리하고 특징을 추출하는 층
- 출력층(Output Layer): 최종 예측이나 분류 결과를 출력하는 층
학습 과정
- 순전파(Forward Propagation): 입력 데이터를 통해 출력값을 계산
- 손실 함수(Loss Function): 출력값과 실제값의 차이를 측정
- 역전파(Backpropagation): 오차를 기반으로 가중치(Weight)를 조정
- 반복적 학습을 통해 모델의 예측 정확도를 점차 향상
활성화 함수(Activation Function)
- 신경망의 각 노드에서 출력값을 변환하여 비선형성을 부여
- 대표적 함수: 시그모이드(Sigmoid), 렐루(ReLU), 하이퍼볼릭 탄젠트(Tanh)

딥러닝의 특징

자동 특징 추출: 데이터에서 유용한 특징을 사람이 일일이 정의하지 않아도 학습 가능
다층 구조: 은닉층이 많을수록 복잡한 패턴 학습 가능
대규모 데이터 적합: 빅데이터와 GPU 연산을 통해 효율적 학습

딥러닝의 주요 응용 분야

이미지 인식

자율주행차의 도로 객체 인식, 의료 영상 진단 등

음성 인식
- 음성 비서, 실시간 통역 시스템
자연어 처리
- 기계 번역, 챗봇, 문서 요약
추천 시스템
- 전자상거래 맞춤형 상품 추천, 동영상 추천 알고리즘

딥러닝의 장점

복잡하고 고차원적인 데이터에서도 높은 정확도 달성 가능
특징 추출 자동화로 데이터 전처리 부담 감소
다양한 분야에서 기존 방법보다 월등한 성능 발휘

딥러닝의 한계

학습에 많은 데이터 필요: 충분한 데이터가 없으면 성능 저하
설명력 부족: 모델의 결정 과정이 불투명, ‘블랙박스’ 문제
연산 비용과 시간 소모: GPU 및 대규모 연산 자원 필요
과적합 위험: 학습 데이터에만 최적화되어 일반화 능력 부족

자연어 처리(NLP)

자연어 처리(NLP, Natural Language Processing)는 인간이 사용하는 언어, 즉 자연어를 컴퓨터가 이해하고 분석하며 생성할 수 있도록 하는 인공지능 기술 분야를 의미한다. 이를 통해 기계는 텍스트와 음성 형태의 언어 데이터를 처리하고, 의미를 파악하거나 적절한 응답을 생성할 수 있다. 번역, 질의응답, 챗봇, 문서 요약 등 다양한 응용 사례를 갖고 있으며, 최근 GPT 계열 모델이 큰 성과를 거두고 있다.

자연어 처리의 주요 목표

언어 이해(Language Understanding)
- 입력된 문장의 의미, 문맥, 의도 등을 파악
- 예: 질문 답변 시스템, 감정 분석
언어 생성(Language Generation)
- 기계가 사람이 이해할 수 있는 자연스러운 문장을 생성
- 예: 챗봇 대화, 자동 문서 요약, 기계 번역

자연어 처리의 핵심 기술

형태소 분석(Morphological Analysis)
- 문장을 구성하는 최소 의미 단위(형태소)로 분리
- 예: “나는 학교에 간다” → [나/는, 학교/에, 가/ㄴ다]
품사 태깅(Part-of-Speech Tagging)
- 각 단어에 명사, 동사, 형용사 등 품사를 부착
- 문장의 구조와 의미 분석 기반 마련
의미 분석(Semantic Analysis)
- 문장이나 단어의 의미를 컴퓨터가 이해하도록 변환
- 예: “은행” → 금융 기관인지 강가인지 판별
구문 분석(Syntactic Parsing)
- 문장의 문법적 구조를 분석하여 주어, 목적어, 동사 관계 확인
텍스트 임베딩(Text Embedding)
- 단어, 문장, 문서 등을 수치 벡터로 변환
- 기계 학습 모델이 자연어 데이터를 처리할 수 있게 함
언어 모델(Language Model)
- 문맥과 패턴을 학습하여 다음 단어 예측
- GPT, BERT 등 최신 모델이 대표적

자연어 처리의 응용 사례

기계 번역: Google 번역, DeepL 등
챗봇 및 대화형 AI: 고객 상담 자동화, 개인 튜터 AI
텍스트 요약: 뉴스 기사, 논문, 보고서 자동 요약
감정 분석: SNS, 리뷰 데이터를 기반으로 긍정·부정 분석
음성 인식 및 음성 합성: Siri, Alexa, TTS(Text-to-Speech) 시스템

자연어 처리의 장점

인간과 기계 간 자연스러운 상호작용 가능
방대한 텍스트 데이터를 자동으로 분석하고 활용 가능
번역, 검색, 추천 등 다양한 서비스 고도화 가능

자연어 처리의 한계

문맥 이해 한계: 복잡한 문맥이나 중의적 표현 이해 어려움
언어 및 문화 편향 문제: 특정 언어·문화 데이터에 의존 시 편향 발생
데이터 의존성: 품질 높은 학습 데이터 없이는 정확도 저하
연산 자원 필요: 대규모 언어 모델 학습 시 막대한 연산 비용 필요

강화학습

강화학습은 보상과 벌점을 기반으로 최적의 행동 전략을 학습하는 기술이다. 알파고의 바둑 대국 승리 사례가 대표적이다.

사례: 알파고와 이세돌의 대국은 강화학습의 실제적 성과를 전 세계에 각인시킨 사건이었다.

강화학습은 에이전트(Agent)가 환경과 상호작용하면서 경험을 통해 최적의 행동 전략을 학습하는 인공지능 기술을 의미한다. 에이전트는 현재의 상태(State)를 관찰하고, 가능한 여러 행동(Action) 중 하나를 선택하며, 그 선택에 대한 보상(Reward)이나 벌점(Penalty)을 받는다. 이러한 피드백을 통해 에이전트는 장기적으로 최대 보상을 얻을 수 있는 행동 정책(Policy)을 점진적으로 개선한다. 강화학습의 핵심은 정답을 명시적으로 알려주지 않아도, 반복적인 시행착오를 통해 스스로 최적 전략을 발견한다는 점에 있다. 대표적 사례로는 **알파고(AlphaGo)**가 있다. 알파고는 수많은 바둑 대국 시뮬레이션과 강화학습을 반복하여 바둑의 최적 수를 학습하였으며, 이 과정에서 인간 챔피언인 이세돌을 상대로 승리하는 성과를 이루어냈다. 이를 통해 강화학습이 복잡한 문제 해결에서도 효과적임을 입증하였다.

ChatGPT와 생성형 AI

Sat, 16 Aug 2025 22:33:00 +0900

GPT의 개념

GPT(Generative Pre-trained Transformer)는 사전 학습을 통해 방대한 언어 패턴을 습득한 후, 새로운 문장을 생성할 수 있는 인공지능 모델이다.

Generative(생성형): 새로운 문장을 생성할 수 있음을 의미한다. 질문에 대한 답변을 산출하거나 글쓰기를 요청받으면 새로운 문장을 만들어낼 수 있다.
Pre-trained(사전 학습된): 방대한 데이터로 미리 학습된 모델을 뜻한다. 책, 웹사이트, 뉴스 등 다양한 텍스트를 기반으로 언어의 규칙과 표현을 습득하였다.
Transformer(트랜스포머): 문장의 의미를 효과적으로 이해하고 처리하기 위해 설계된 모델 구조의 명칭이다. 이는 구글에서 개발한 기술이다.

작동 방식

사전 학습(Pre-training) GPT는 인터넷에 존재하는 방대한 텍스트 데이터를 학습하여 언어의 패턴, 문법, 의미 등을 습득한다. 예를 들어, “하늘이 파란 이유는"이라는 문장이 주어지면, 그 뒤에 “햇빛이 산란되기 때문이다"라는 서술이 자주 등장한다는 사실을 학습한다.
추론(Inference) 사전 학습이 완료된 GPT는 사용자로부터 질문을 입력받으면, 그에 적합하고 자연스러운 답변을 생성한다.
문맥 이해(Context Understanding) GPT는 이전 문맥을 참조하여 상황에 맞는 응답을 하려고 한다. 예컨대, 대화 중 앞에서 “봄"에 관한 언급이 있었다면, 꽃이나 날씨와 같은 주제를 더 잘 연상하여 활용할 수 있다.

GPT의 장점

다양한 언어 작업 수행 가능 질문 응답, 글쓰기, 번역, 요약, 문법 교정 등 여러 언어 처리 작업을 수행할 수 있다.
자연스러운 표현 생성 GPT 기반 챗봇은 대화체 문장을 자연스럽게 산출할 수 있어, 사람과 대화하는 듯한 경험을 제공한다.
신속한 반응 원하는 정보를 수 초 내에 생성하여 제공한다.

ChatGPT의 등장

ChatGPT는 OpenAI가 개발한 대규모 언어 모델(LLM, Large Language Model) 기반의 대화형 인공지능 서비스이다. GPT(Generative Pre-trained Transformer) 기술을 바탕으로 인간과 유사한 자연스러운 대화를 수행하며, 질의응답, 문서 작성, 번역, 요약 등 다양한 언어 처리 작업을 지원한다. 자연스러운 문맥 이해와 다언어 지원 능력이 강점이다.

https://chatgpt.com/

명칭의 의미

Chat: 사용자와의 대화 인터페이스를 의미한다.
GPT: 문장 생성 능력을 갖추고 사전 학습된 트랜스포머 아키텍처 기반 모델이다.

“GPT 기술을 기반으로 한 대화형 서비스"이라는 의미를 내포한다.

특징 및 기능

다양한 활용성
- 질문 응답, 문장 작성, 번역, 요약, 프로그램 작성(코드 지원) 등이 가능하다.
자연스러운 대화 능력
- 사람과 대화하는 듯한 자연스러운 응답을 생성할 수 있다.
다언어 대응
한글을 포함한 다양한 언어로 의사소통이 가능하다.
기술적 유연성
- 다양한 형식의 출력—텍스트, 코드, 표, JSON 등—생성 가능하며, 노코드 환경에서도 활용할 수 있다.

주요 특징

다양한 언어 작업 수행 가능
- 질문 응답, 글쓰기, 번역, 요약, 문법 교정, 코드 작성 등 폭넓은 활용이 가능하다.
자연스러운 대화 생성
- 사람과 대화하는 듯한 자연스러운 언어 표현을 산출할 수 있다.
다언어 지원
- 한국어를 포함한 다수의 언어로 의사소통이 가능하다.
출력 형식의 유연성
- 텍스트뿐 아니라 코드, 표, JSON 등 다양한 형식으로 결과를 제공할 수 있다.

기술적 기반

사전 학습(Pre-training): 웹, 도서, 논문, 소스 코드 등 방대한 텍스트 데이터를 기반으로 언어의 구조와 의미를 학습하였다.
Transformer 아키텍처: 문맥 이해와 문장 생성을 위한 핵심 기술로, Self-Attention 메커니즘을 활용하여 단어 간 관계를 효과적으로 파악한다.

활용 사례

ChatGPT의 활용 범위는 매우 다양하며, 여러 산업과 분야에서 실제로 적용되고 있다. 대표적인 활용 사례를 살펴보면 다음과 같다.

고객 서비스 자동화
- 기업의 고객 지원 부서에서는 ChatGPT를 활용하여 24시간 온라인 상담 서비스를 제공하고 있다. 이를 통해 고객의 기본적인 문의를 신속히 처리할 수 있으며, 상담원이 복잡한 문제에 집중할 수 있도록 지원한다.
교육 및 학습 지원
- 교육 현장에서 ChatGPT는 학생 개개인의 학습 속도와 수준에 맞춘 맞춤형 학습을 제공한다. 학생이 질문을 입력하면 AI가 이해하기 쉬운 답변을 제공하고, 추가 학습 자료를 추천함으로써 학습 효율을 높인다.
프로그래밍 코드 보조
- 프로그래머들은 ChatGPT를 활용하여 코드 작성 및 디버깅을 보조받을 수 있다. 반복적인 코드 작성 작업이나 함수 템플릿 생성, 오류 검토 등을 자동화함으로써 개발 속도를 향상시키고, 생산성을 높인다.
콘텐츠 생성 및 요약
- ChatGPT는 기사 요약, 광고 문구 작성, 보고서 작성 등 다양한 콘텐츠 생성 업무를 수행할 수 있다. 또한, 방대한 문서를 요약하여 핵심 정보를 빠르게 전달함으로써 정보 처리 효율을 높인다.

한계와 과제

ChatGPT의 활용에는 분명한 장점이 존재하지만, 동시에 다음과 같은 한계와 과제가 있다.

사실 오류 발생 가능성

ChatGPT는 학습된 데이터에 기반하여 답변을 생성하므로, 때때로 잘못된 정보나 오류가 포함될 수 있다. 따라서 중요한 의사결정에 활용할 때는 추가 검증이 필요하다.

최신 정보 반영의 한계
- 모델이 학습된 시점 이후의 최신 정보나 사건은 반영되지 않을 수 있다. 실시간 정보가 필요한 분야에서는 보조적 도구로 활용하는 것이 적절하다.
- 다만, 최신 GPT 모델은 인터넷 검색 기능과 연동되어 이를 보완하기도 한다.
데이터 사용과 저작권 문제
- ChatGPT가 학습한 데이터에는 저작권이 존재할 수 있으며, 생성된 콘텐츠 또한 지적 재산권 문제와 연결될 수 있다. 따라서 상업적 활용 시 법적 문제에 주의해야 한다.
예측 기반의 작동 원리

GPT는 단어의 다음 위치를 확률적으로 예측하는 방식으로 작동한다. 따라서 인간과 같은 심층적 이해나 감정을 지니는 것은 아니며, 의미를 “이해"한다기보다는 패턴을 “예측"한다고 보는 것이 타당하다.

인공지능의 응용 분야

Sat, 16 Aug 2025 22:33:00 +0900

의료

의료 영상 분석, 신약 개발, 환자 맞춤형 치료

사례: 구글의 딥마인드(DeepMind)가 개발한 AI는 안과 질환을 조기 발견하는 데 활용되고 있다.
이미지 출처: 로봇신문" 구글 딥마인드, 인공지능 활용해 안과질환 조기 진단

의료 AI의 실제 사례

영상 진단: AI가 엑스레이와 MRI 이미지를 판독해 초기 암을 조기 발견. 미국의 한 병원에서는 판독 오류율이 20% 감소.
신약 개발: 기존에는 10년 이상 걸리던 후보 물질 탐색을 AI 기반으로 수개월 내 단축.
맞춤형 치료: 환자의 유전자 정보를 분석해 가장 효과적인 항암제를 추천.

그림 3: AI 활용 전통적 신약 개발 프로세스 vs AI 기반 프로세스 비교

자율주행

자율주행 기술은 도로 상황을 실시간으로 인식하고, 이를 기반으로 최적의 주행 전략을 결정하며 교통 흐름을 효율적으로 관리하는 것을 목표로 한다. 카메라, 레이더, 라이다(LiDAR) 등의 센서를 통해 주변 환경을 탐지하고, AI 알고리즘이 이를 분석하여 차량의 속도, 방향, 차간 거리 등을 자동으로 조절한다. 이를 통해 교통사고를 줄이고, 도로 효율성을 높이며, 운전자와 보행자의 안전을 강화할 수 있다.

금융

금융 분야에서 AI는 사기 거래 탐지, 투자 전략 자동화, 리스크 관리 등 다양한 영역에 적용되고 있다. 사기 탐지에서는 비정상적인 거래 패턴을 실시간으로 분석하여 의심 거래를 식별하며, 투자 전략 자동화에서는 시장 데이터를 기반으로 포트폴리오 최적화를 수행한다. 또한 AI는 금융 기관이 신용 위험, 시장 위험 등을 예측하고 관리하는 데 활용되어 금융 안정성과 운영 효율성을 동시에 높인다.

제조업

제조업에서는 스마트 공장 구현, 예지 보수, 품질 관리 자동화 등에 AI가 적용된다. 스마트 공장은 생산 설비와 물류 시스템을 AI로 연결하여 효율적인 공정 관리를 가능하게 한다. 예지 보수(Predictive Maintenance)는 센서 데이터를 분석하여 장비 고장을 사전에 예측하고, 유지보수 계획을 최적화함으로써 비용과 시간을 절감한다. 품질 관리 자동화는 생산 과정에서 발생할 수 있는 결함을 실시간으로 감지하여 제품 품질을 향상시킨다.

교육

교육 분야에서는 AI를 활용하여 맞춤형 학습, 자동 채점, 지능형 튜터링 시스템 등을 제공한다. 학생 개개인의 학습 수준과 속도를 분석하여 개인화된 학습 콘텐츠를 추천하고, 과제와 시험을 자동으로 채점하여 교사의 업무 부담을 경감시킨다. 또한 지능형 튜터링 시스템은 학생의 학습 패턴을 분석하여 취약한 영역을 보완하고, 실시간 피드백을 제공함으로써 학습 효과를 극대화한다.

윤리와 미래 전망

Sat, 16 Aug 2025 22:33:00 +0900

윤리적 고려 사항

인공지능 기술의 발전과 확산은 다양한 윤리적 문제를 동반한다. 주요 고려 사항은 다음과 같다.

개인정보 보호
- AI 시스템은 대량의 데이터에 의존하여 학습하고 작동한다. 이 과정에서 개인의 민감한 정보가 수집, 처리될 수 있으며, 정보 유출이나 오남용 위험이 존재한다. 따라서 AI 개발과 활용 시에는 개인정보 보호법 준수와 안전한 데이터 관리가 필수적이다.
알고리즘 편향
- AI 모델은 학습 데이터에 포함된 편향을 그대로 학습할 수 있다. 이는 특정 집단이나 개인에 대한 불공정한 판단, 차별적 결과를 초래할 수 있으며, 사회적 신뢰를 저해할 수 있다. 이를 방지하기 위해서는 데이터 편향성을 검토하고, 공정성을 고려한 알고리즘 설계가 필요하다.
인간 노동 대체 문제
- AI의 자동화 능력은 생산성과 효율성을 높이는 동시에 일부 직업의 역할을 대체할 수 있다. 이는 고용 구조 변화와 사회적 불평등 문제를 야기할 수 있으며, 이에 대한 정책적 대비와 재교육 프로그램 마련이 중요하다.

구체적인 표현은 보호되지만, 추상적인 아이디어는 보호되지 않는다.

그러면, “지브리 스타일"은 인터넷에 올려도 되는가? 법적으로는 문제가 없더라도 AI 윤리의 괌점에서는 적절한 이용이라고 할 수 없다.

인공지능의 미래

인공지능은 단순한 도구를 넘어 인간과 협력하며 지능적 결정을 지원하는 동반자로 진화할 것으로 전망된다. 미래 사회에서 AI는 의료, 교육, 산업 등 다양한 분야에서 인간의 역량을 보조하고 효율성을 극대화하는 역할을 수행할 것이다. 그러나 기술 발전의 속도가 매우 빠른 만큼, 사회적·법적 제도와 규범의 정비가 병행되지 않으면, 개인정보 침해, 불공정한 판단, 고용 불안 등 다양한 문제를 야기할 수 있다. 따라서 AI의 잠재적 이점을 최대화하고 부작용을 최소화하기 위해서는 기술적 혁신과 함께 윤리적, 법적, 사회적 준비가 필수적이다.

맺음말

Sat, 16 Aug 2025 22:33:00 +0900

맺음말

인공지능은 이미 우리 사회 전반에 걸쳐 필수적인 기술로 자리잡았다. 본 도서를 통해 독자들이 AI의 개념과 원리를 올바르게 이해하고, 각자의 분야에서 효과적으로 활용할 수 있기를 기대한다.

인공지능 학습

LinkedIn Learning | Generative AI is a tool in service of humanity
- 생성형 AI 기초에 대해 학습 과정
LinkedIn Learning | Applying Generative AI as a Creative Professional
- 창작자를 위한 생성형 AI 과정
경기도평생학습포털 | 생성한 AI 강좌
- 생성형 AI 강좌

Kotlin 문자열 템플릿(string template)

Wed, 18 Sep 2024 14:10:00 +0900

문자열 리터럴 안에서 "$변수명"이나 "${표현식}"과 같이 작성하면 변수의 값이나 식의 평가 결과를 문자열로 확장할 수 있다.

val name = "devkuma"
println("Hello, $name!")

Output:

Hello, devkuma!

이런 구조를 문자열 템플릿(string template)이라고 한다. "${표현식}"을 사용하는 방법을 이용하면 문자열 템플릿 안에서 함수 호출 등을 할 수 있다.

println("You are ${p.age} years old.")  // getAge()의 호출

다만, 너무 복잡한 수식을 쓰려고 하면 가독성이 떨어지니 적당히 사용해야 한다.

fun main(args: Array<String>) {
    println("Hi, ${if (args.isEmpty()) "anonymous" else args[0]}")
}

Kotlin 문자열

Wed, 18 Sep 2024 14:10:00 +0900

Kotlin 목록, 배열 길이 구하기

Sun, 15 Sep 2024 11:26:00 +0900

size를 이용한 방법

목록, 배열에서는 size는 변수를 제공하며, 길이 값을 저장되어 있다.

아래와 같이 size 변수로 목록, 배열의 길이를 가져올 수 있다.

fun main() {
    val array = arrayOf(1, 2, 3, 4, 5)
    println("array size: ${array.size}")

    val list = listOf("a", "b", "c", "d", "e")
    println("list size: ${list.size}")
}

Output:

array size: 5
list size: 5

count()를 이용한 방법

목록, 배열에서는 count() 함수를 제공하며, 요소들의 개수를 반환한다.

아래와 같이 count()를 사용하여 목록, 배열의 길이를 가져올 수 있다.

fun main() {
    val array = arrayOf(1, 2, 3, 4, 5)
    println("array count: ${array.count()}")

    val list = listOf("a", "b", "c", "d", "e")
    println("list count: ${list.count()}")
}

Output:

array count: 5
list count: 5

Kotlin 목록(List) 선언, 초기화

Sun, 15 Sep 2024 00:54:00 +0900

목록(List)

listOf()으로 목록을 생성한다. 배열 개수 고정인데 비해 목록은 .add() 및 .remove()으로 추가 삭제할 수 있다. 그러나 배열은 nums[1] = 123으로 값을 변경할 수 있지만, 목록은 nums[1] = 222으로 값을 변경할 수 없다.

fun main() {
    val nums = listOf(1, 2, 3)
    val cols = listOf("Red", "Green", "Blue")

    for (n in nums) { println(n) }
    for (c in cols) { println(c) }
}

Output:

1
2
3
Red
Green
Blue

주요 함수

filter 함수

아래와 같이 목록에 필터를 걸어 짝수인 조건에 일치하는 요소를 추출할 수 있다.

fun main() {
    val nums = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    println(nums.filter { it % 2 == 0 })
}

Output:

[2, 4, 6, 8, 10]

Kotlin 배열(Array) 선언, 초기화, 주요 함수

Sun, 15 Sep 2024 00:11:00 +0900

배열(Array)

arrayOf()으로 배열을 생성한다. 배열의 개수는 고정이긴 하지만 성능이 우수하다.

fun main() {
    val nums = arrayOf(1, 2, 3)
    val cols = arrayOf("Red", "Green", "Blue")

    for (n in nums) { println(n) }
    for (c in cols) { println(c) }
}

Output:

1
2
3
Red
Green
Blue

아래와 같이 변수 선언시에 Array<Int> 타입을 입력하면, 뒤 부분의 타입은 <>으로 생략할 수 있다.

val array: Array<Int> = emptyArray<>()

대괄호 [...]로 배열의 요소에 접근할 수 있으며, 배열의 인덱스는 0부터 시작한다.

println(nums[0])
println(cols[1])

빈(Empty) 배열 선언

아래 함수로 특정 타입의 빈 배열을 선언할 수 있다.

val array1 = emptyArray<Int>()
val array2 = arrayOf<Int>()
``

```kotlin
fun main() {
    val array1 = emptyArray<Int>()
    println("array1: ${array1.contentToString()}")

    val array2 = arrayOf<Int>()
    println("array2: ${array2.contentToString()}")
}

Output:

array1: []
array2: []

배열 선언 시, 초기 값 설정

arrayOf<Type>(values)로 배열에 초기 값을 설정할 수 있다. 이때, (values)로 타입을 유추할 수 있기 때문에 <Type>은 생략할 수 있다.

fun main() {
    val array1 = arrayOf<Int>(1, 2, 3, 4)
    println("array1: ${array1.contentToString()}")

    val array2 = arrayOf("Red", "Green", "Blue")
    println("arr: ${array2.contentToString()}")
}

Output:

array1: [1, 2, 3, 4]
array2: [Red, Green, Blue]

동일한 값으로 배열 초기화

Array(size) { value }는 배열을 size로 설정한 크기 만큼 생성하며, 요소들을 모두 설정한 value로 할당한다.

fun main() {
    val array = Array(3) { 20 }
    println("array: ${array.contentToString()}")
}

Output:

array: [20, 20, 20]2

연속된 숫자로 배열 초기화

Array(size) { lambda }는 배열을 size로 설정한 크기 만큼 생성하며, 요소들을 모두 lambda의 반환 값으로 설정된다.

lambda에 전달되는 it는 요소의 index 값이 되며, 아래와 같이 연속된 숫자로 배열을 초기화할 수 있다.

fun main() {
    val array1 = Array(5) { it -> it }
    println("array1: ${array1.contentToString()}")

    val array2 = Array(5) { it -> it + 10 }
    println("array2: ${array2.contentToString()}")
}

Output:

array1: [0, 1, 2, 3, 4]
array2: [10, 11, 12, 13, 14]

Null로 배열 초기화

arrayOfNulls<Type>(size)로 null로 가득찬 배열을 생성할 수 있다.

fun main() {
    val array = arrayOfNulls<Int>(5)
    println("array: ${array.contentToString()}")
}

Output:

array: [null, null, null, null, null]

기본 자료형 배열 선언

kotlin에는 IntArray, BooleanArray, DoubleArray, LongArray 등, 기본 자료형 배열을 제공한다.

이런 배열을 생성할 때는 intArrayOf(), booleanArrayOf() 등을 사용하여 생성할 수 있다.

fun main() {
    val iniArray: IntArray = intArrayOf(1, 2, 3)
    println("iniArray: ${iniArray.contentToString()}")

    val booleanArray: BooleanArray = booleanArrayOf(true, true, false)
    println("booleanArray: ${booleanArray.contentToString()}")

    val doubleArray: DoubleArray = doubleArrayOf(1.2, 2.3, 3.4)
    println("doubleArray: ${doubleArray.contentToString()}")
}

Output:

iniArray: [1, 2, 3]
booleanArray: [true, true, false]
doubleArray: [1.2, 2.3, 3.4]

주요 함수

forEach 함수

forEach 함수는 목록에 반복 처리를 할 수 있다.

fun main() {
    val array = arrayOf(1, 2, 3, 4, 5)

    // lambda으로 사용한 방법이다.
    array.forEach({ element ->
        print("$element,")
    }) // => 1,2,3,4,5
    println()

    // 괄호'()'은 생략할 수 있다.
    array.forEach { element ->
        print("$element,")
    }
    println()

    // it으로 람다를 대신하여 객체를 받아올 수 있다.
    array.forEach {
        print("$it,")
    } // => 1,2,3,4,5
}

Output:

1,2,3,4,5,
1,2,3,4,5,
1,2,3,4,5,

forEach에 대한 kotlin 공식 문서

filter 함수

filter 함수는 목록에 조건을 걸어 그 조건에 맞는 새로운 목록을 반환한다.

fun main() {
    val array = arrayOf(1, 2, 3, 4, 5) // => 1,2,3,4,5 배열을 생성한다.

    // filter의 조건에 충족되는 함수를 반환한다.
    array.filter({ e -> e % 2 == 0 }).forEach { println(it) } // => 2,4

    // 괄호'()'은 생략할 수 있다.
    array.filter { e -> e % 2 == 0 }.forEach { println(it) } // => 2,4

    // lambda 사용하지 않고도 'it'으로 객체를 받아 올 수 이 있다.
    array.filter { it % 2 == 0 }.forEach { println(it) } // => 2,4

}

Output:

2,4,
2,4,
2,4,

filter 함수에 대한 kotlin 공식 문서

map 함수

map 함수는 목록의 요소를 변경하여 받아올 수 있다.

// 이름과 연령을 갖는 클래스 정의
private class Person(val name: String, val age: Int)

fun main() {
    val array = arrayOf(
        Person("Charlie", 20),
        Person("devkuma", 31),
        Person("kimkc", 42),
    )

    // lambda으로 user 인스턴스를 받아 올수 있다.
    array.map({ user -> user.name }).forEach { print("${it},") }
    println()

    // 괄호'()'은 생략할 수 있다.
    array.map { user -> user.name }.forEach { print("${it},") }
    println()

    // 'it'으로 객체를 받아 올 수 있다(이 'it'는 user 인스턴스를 가르킨다).
    array.map { it.name }.forEach { print("${it},") }
}

Output:

Charlie,devkuma,kimkc,
Charlie,devkuma,kimkc,
Charlie,devkuma,kimkc,

map 함수에 대한 kotlin 공식 문서

sum 함수

sum 함수는 입력한 숫자를 합산한다.

fun main() {
    // Array<Int> 인스턴스 생성한다.
    val array = arrayOf(1, 2, 3, 4, 5)

    // 합산한다(1 + 2 + 3 + 4 + 5).
    println(array.sum()) // => 15
}

Output:

sum 함수에 대한 kotlin 공식 문서

take 함수

take 함수는 목록의 요소를 입력한 숫자 만큼만 가져온다.

fun main() {
    val array = arrayOf(1, 2, 3, 4, 5)
    array.take(1).forEach { print(it) } // => 1
    println()
    array.take(2).forEach { print(it) } // => 1, 2
    println()
    array.take(3).forEach { print(it) } // => 1, 2, 3
    println()
    array.take(4).forEach { print(it) } // => 1, 2, 3, 4
    println()
    array.take(5).forEach { print(it) } // => 1, 2, 3, 4, 5
}

Output:

take 함수에 대한 kotlin 공식 문서

drop 함수

drop 함수는 목록의 요소를 앞에서 부터 입력한 숫자 만큼 제거하고 가져온다.

fun main() {
    val array = arrayOf(1, 2, 3, 4, 5)
    array.drop(1).forEach{print(it)} // => 2, 3, 4, 5
    println()
    array.drop(2).forEach{print(it)} // => 3, 4, 5
    println()
    array.drop(3).forEach{print(it)} // => 4, 5
    println()
    array.drop(4).forEach{print(it)} // => 5
    println()
    array.drop(5).forEach{print(it)} // => 빈 Array
}

Output:

drop 함수에 대한 kotlin 공식 문서

Kotlin 배열(Array)에서 최소값, 최대값 찾기

Sat, 14 Sep 2024 23:40:00 +0900

minOrNull(), minOrNull()를 이용한 방법

Array에서 제공하는 minOrNull(), maxOrNull() 함수는 배열의 최소값, 최대값을 반환한다.

fun main() {
    val array = arrayOf(66, 10, 34, 70, 42)

    println("min: ${array.minOrNull()}")
    println("max: ${array.maxOrNull()}")
}

Output:

min: 10
max: 70

Tip

기존에 `Array`에서 제공하는 `min()`, `max()` 함수는 1.4 버전 이후로 deprecated 되었다.

정렬을 이용한 방법

Array.sorted() 함수는 오름차순으로 정렬된 배열을 반환한다.

오름차순으로 정렬되었기 때문에, Index의 첫번째 요소는 최소값이 되고, 마지막 요소는 최대값이 된다.

fun main() {
    val array = arrayOf(66, 10, 34, 70, 42)

    val sortedArray = array.sorted()

    println("min: ${sortedArray.first()}")
    println("max: ${sortedArray.last()}")
}

Output:

min: 10
max: 70

반복문을 이용한 방법

for문으로 배열의 모든 요소를 반복하면서, 최소값과 최대값을 찾을 수도 있다.

아래와 같이 min 변수의 초기 값을 Int의 최대값, max 변수의 초기 값을 Int의 최소값으로 할당하고 for문으로 반복하면서 값을 찾는다.

fun main() {
    val array = arrayOf(66, 10, 34, 70, 42)

    var max = Int.MIN_VALUE
    var min = Int.MAX_VALUE
    for (i in array) {
        min = if (min > i) i else min
        max = if (max < i) i else max
    }

    println("min: $min")
    println("max: $max")
}

Output:

min: 10
max: 70

개발 문서 사이트

Sun, 01 Sep 2024 10:28:00 +0900

프로그래밍 시작

생활코딩 / 오픈튜토리얼스

기초 프로그래밍 입문 강좌 사이트

무료 프로그래밍 학습 과정

W3schools

최대 WEB 프로그래밍 시작 지침

사용자 수가 많은 무료 WEB 개발 학습 사이트

tutorialspoint

기초 프로그래밍 입문 강좌 사이트

무료 주제 프로그래밍 강좌가 많이 포함되어 있다.

공식 기술 문서

php

php 공식 문서

PHP 자습서 및 API 문서를 제공한다.

GO

GO 공식 문서

GO 공식 자습서 및 API 문서

모바일

Swift

Swift 공식 문서

Apple Swift 공식 자습서 및 API 문서

Java 기술 문서

HowToDoInJava

Javatpoint

javadevJournal

Baeldung

Mkyong.com

WEB & 프런트엔드 개발

Bootstrap

Bootstrap 공식 문서

CSS 프레임워크

Vue.js

Vue.js 공식 문서

Javascript 프레임워크
Vue.js 프레임워크 학습 문서

KoXo

자바스크립트 매뉴얼

Javascript API 문서를 소개한다.

javascript.info

javascript 기초 지식

기초 학습 JS, 최고의 강좌이다.

jQuery

jQuery 공식 문서

Javascript 프레임워크

데이터베이스

Elasticsearch

엘라스틱 서치 공식 문서

엘라스틱 서치 검색 엔진에 대해서 소개한다.

MySQL

MySQL 공식 문서

MySQL에 대해서 소개한다.

PostgreSQL

PostgreSQL 공식 문서

PostgreSQL에 대해서 소개한다.

SQLite

SQLite 공식 문서

파일형 경량 데이터베이스

서버

Docker

도커 공식 문서

kubernetes

쿠버네티스 공식 문서

K8s 클러스터 구축에 대한 소개

기술 커뮤니티(한국어)

WikiDocs

프로그래밍 서적 번역

프로그래밍 입문서들을 찾을 수 있다

기술 문서(영문)

roadmap.sh

일본 개발 커뮤니터 사이트

초보자에서 학습 로드맴 제공
Backend Developer

Real’s How-to

ideone

Backjoon Online Judge

Webhacking.kr

CODE COMBAT

기술 커뮤니티(일본어)

Qiita

일본 개발 커뮤니터 사이트

엔지니어의 지식을 기록하고 공유하기 위한 서비스이다. 프로그래밍에 관한 Tips, 노하우, 메모를 쉽게 기록 & 게시되어 있다.

DevolpersIO

기술 미디어 사이트

AWS, 클라우드, 생성 AI, 데이터 분석, 앱 개발 등의 기술 정보부터 DX, 이벤트 리포트, SaaS와 Python, Google Cloud 등 다양한 주제를 소개한다.

Sites

Sun, 01 Sep 2024 10:28:00 +0900

유용한 사이트 모음

Kotest 라이프사이클 후크(Lifecycle Hooks)

Tue, 23 Apr 2024 00:37:00 +0900

테스트 라이프사이클 관리

테스트 라이프사이클 관리는 각 테스트 케이스의 실행 전후에 필요한 작업을 수행하는 것을 의미한다. Kotest는 beforeTest와 afterTest 블록을 제공하여 테스트 라이프사이클을 관리할 수 있다. 이를 통해 각 테스트 케이스의 실행 전후에 필요한 설정 또는 정리 작업을 수행할 수 있다.

라이프사이클 후크

각 테스트 케이스의 실행 전후에 어떤 작업을 수행해야 하는 경우가 있다. 예를 들어, 데이터베이스 연결을 설정하거나 정리하는 작업, 테스트 시간을 측정 등의 필요한 설정 또는 정리 작업이 있을 수 있다. 이때 사용하는 것이 라이프사이클 후크(Lifecycle Hooks)이다.

Kotest는 스펙 내에서 직접 정의할 수 있는 다양한 종류의 후크를 제공한다. 배포 가능한 플러그인이나 재사용 가능한 후크 작성과 같은 더 발전된 경우의 확장(Extentions)을 사용할 수도 있다.

이 섹션의 마지막에는 사용 가능한 후크 목록과 실행 시기가 나와 있다.

Kotest에서 후크를 사용하는 방법에는 여러 가지가 있다:

DSL 메서드으로 작성하기

첫번째로 가장 간단한 방법은 스펙 내에서 사용 가능한 DSL 메서드를 사용하여 TestListener를 생성하고 등록하는 것이다. 예를 들어, 다음과 같이 beforeTest, afterTest를 직접 호출할 수 있다.

package com.devkuma.kotest.tutorial.lifecycle.ex1

import io.kotest.core.spec.style.WordSpec

class TestSpec : WordSpec({
    beforeTest {
        println("Starting a test $it")
    }

    afterTest { (test, result) ->
        println("Finished spec with result $result")
    }

    "this test" should {
        "be alive" {
            println("devkuma is alive!")
        }
    }
})

다음은 예제를 실행한 결과이다:

Starting a test TestCase(descriptor=TestDescriptor... 생략 ...
Starting a test TestCase(descriptor=TestDescriptor... 생략 ...
Johnny5 is alive!
Finished spec with result Success(duration=6ms)
Finished spec with result Success(duration=51ms)

백그라운드에서 이러한 DSL 메서드는 적절한 함수를 재정의하고, 이 테스트 리스너가 실행되도록 등록한 TestListener의 인스턴스를 생성한다.

프로젝트 리스너의 인스턴스를 생성하는 DSL 메서드로 afterProject를 사용할 수 있지만, 프레임워크가 스펙을 감지하는 이 단계에 있을 때는 이미 프로젝트가 시작되었으므로 beforeProject는 없다!

함수를 사용하는 DSL 메서드

이러한 DSL 메서드는 함수를 받으므로, 함수에 대한 로직을 가져와 여러 곳에서 재사용할 수 있다.

package com.devkuma.kotest.tutorial.lifecycle.ex2

import io.kotest.core.spec.style.WordSpec
import io.kotest.core.test.TestCase

val startTest: suspend (TestCase) -> Unit = {
    println("Starting a test $it")
}

class TestSpec : WordSpec({

    // used once
    beforeTest(startTest)

    "this test" should {
        "be alive" {
            println("devkuma is alive!")
        }
    }
})

class OtherSpec : WordSpec({

    // used twice
    beforeTest(startTest)

    "this test" should {
        "fail" {
            println("boom")
        }
    }
})

다음은 예제를 실행한 결과이다:

Starting a test TestCase(descriptor=TestDescriptor... 생략 ...
boom
Starting a test TestCase(descriptor=TestDescriptor... 생략 ...
devkuma is alive!

스펙에서 콜백 함수 재정의하기

두 번째 방법으로는 스펙에서 콜백 함수를 재정의하는 것이다. 아래 예제는 첫 번째 방법을 변형하였다.

package com.devkuma.kotest.tutorial.lifecycle.ex3

import io.kotest.core.spec.style.WordSpec
import io.kotest.core.test.TestCase
class TestSpec : WordSpec() {

    override suspend fun beforeTest(testCase: TestCase) {
        println("Starting a test $testCase")
    }

    init {
        "this test" should {
            "be alive" {
  println("devkuma is alive!")
            }
        }
    }
}

라이프사이클 콜백

모든 콜백을 올바르게 이해하려면, 가능한 TestType 값을 이해하는 것이 중요하다:

Container: 다른 테스트를 포함할 수 있는 컨테이너
Test: 중첩된 테스트를 포함할 수 없는 리프(Leaf) 테스트. 즉, 다른 테스트를 호출하지 않고 독립적으로 실행될 수 있는 테스트
Dynamic: 컨테이너 또는 테스트가 될 수 있으며, 속성 테스트 또는 데이터 테스트와 같은 기능을 통해 테스트가 동적으로 추가될 때 사용

Kotest에서는 테스트 수명주기에 따라 실행되는 여러 종류의 콜백 함수를 제공한다.

아래는 Kotest에서 사용되는 각 콜백에 대한 설명이다:

콜백	설명
`beforeContainer`	컨테이너(Test container) 내의 모든 테스트가 실행되기 전에 호출되는 콜백이다.
`afterContainer`	컨테이너(Test container) 내의 모든 테스트가 실행된 후에 호출되는 콜백이다.
`beforeEach`	각 테스트 케이스(Test case) 실행 전에 호출되는 콜백이다. 각 테스트마다 별도의 설정을 수행하고 싶을 때 사용된다.
`afterEach`	각 테스트 케이스(Test case) 실행 후에 호출되는 콜백이다. 각 테스트마다 별도의 정리 작업을 수행하고 싶을 때 사용된다.
`beforeAny`	특정 컨테이너 또는 스펙 내의 모든 테스트가 실행되기 전에 호출되는 콜백이다. 특정 컨테이너나 스펙 내의 모든 테스트에 대한 공통적인 설정 작업을 수행하고자 할 때 사용된다.
`afterAny`	특정 컨테이너 또는 스펙 내의 모든 테스트가 실행된 후에 호출되는 콜백이다. 특정 컨테이너나 스펙 내의 모든 테스트에 대한 공통적인 정리 작업을 수행하고자 할 때 사용된다.
`beforeTest`	각 테스트 메소드(Test method) 실행 전에 호출되는 콜백이다. 이 함수를 사용하여 각 테스트의 설정을 수행할 수 있다. beforeAny와 동일한 동작을 한다.
`afterTest`	각 테스트 메소드(Test method) 실행 후에 호출되는 콜백이다. 이 함수를 사용하여 각 테스트의 정리 작업을 수행할 수 있다. afterAny와 동일한 동작을 한다.
`beforeSpec`	각 스펙(Spec) 실행 전에 호출되는 콜백이다. 스펙 전체에 대한 설정 작업을 수행하고자 할 때 사용된다. 예를 들어, 데이터베이스 연결을 설정하거나 특정 자원을 초기화하는 작업을 수행할 수 있다. `IsolationMode`가 `SingleInstance`인 경우, `prepareSpec`과 같은 동작을 한다.
`afterSpec`	각 스펙(Spec) 실행 후에 호출되는 콜백이다. 스펙 전체에 대한 정리 작업을 수행하고자 할 때 사용된다. 예를 들어, 데이터베이스 연결을 닫거나 특정 자원을 정리하는 작업을 수행할 수 있다. `IsolationMode`가 `SingleInstance`인 경우, `finalizeSpec`과 같은 동작을 한다. 해당 Callback에서 예외가 발생하면 이후 `beforeSpec`, `AfterSpec`은 스킵된다.
`prepareSpec`	스펙(Spec)이 실행되기 전에 호출되는 콜백으로, 사용자 정의 초기화 작업을 수행하는 데 사용된다. `IsolationMode`가 SingleInstance인 경우, beforeSpec과 같은 동작을 한다.
`finalizeSpec`	스펙(Spec)이 실행된 후에 호출되는 콜백으로, 사용자 정의 정리 작업을 수행하는 데 사용된다. `IsolationMode`가 `SingleInstanc`e인 경우, `afterSpec`과 같은 동작을 한다.
`beforeInvocation`	각 테스트 메소드(Test method) 또는 테스트 케이스(Test case) 실행 전에 호출되는 콜백이다. invocation 설정이 없으면 beforeTest와 같은 동작을 한다.
`afterInvocation`	각 테스트 메소드(Test method) 또는 테스트 케이스(Test case) 실행 후에 호출되는 콜백이다. invocation 설정이 없으면 afterTest와 같은 동작을 한다.

이러한 콜백들은 각 테스트 실행 전후나 스펙 실행 전후 등의 다양한 시점에 특정 동작을 수행할 수 있도록 도와준다. 각 콜백은 해당하는 시점에 호출되며, 필요에 따라 적절한 로직을 구현하여 사용할 수 있다.

beforeAny과 beforeTest는 동일한 함수의 다른 이름일 뿐이지만, beforeEach와는 다르다. beforeAny, beforeTest 각각 TestType.Test 전에 호출되는 반면, beforeEach는 TestType.Container와 TestType.Test 전에 호출된다. afterAny, afterTest 및 afterEach에도 동일하게 적용된다.

다음 콜백 함수가 언제 실행되는 알수 있는 예시를 통해서 알아보겠다:

package com.devkuma.kotest.tutorial.lifecycle.ex4

import io.kotest.core.spec.style.StringSpec
import io.kotest.matchers.shouldBe

class CallbackTest : StringSpec({

    // 각 스펙이 실행되기 전에 호출되는 콜백
    beforeSpec {
        println("beforeSpec: 스펙 실행 전 설정을 수행.")
        // 스펙 전체에 대한 설정 작업을 추가.
    }

    // 각 스펙이 실행된 후에 호출되는 콜백
    afterSpec {
        println("afterSpec: 스펙 실행 후 정리를 수행.")
        // 스펙 전체에 대한 정리 작업을 추가.
    }

    // 각 테스트 실행 전에 호출되는 콜백
    beforeTest { testCase ->
        println("beforeTest: ${testCase.name.testName} 실행 전 설정을 수행.")
        // 여기에 테스트의 공통 설정 작업을 추가.
    }

    // 각 테스트 실행 후에 호출되는 콜백
    afterTest { (testCase, testResult) ->
        println("afterTest: ${testCase.name.testName} 실행 후 정리를 수행.")
        println("결과: $testResult")
        // 여기에 테스트의 공통 정리 작업을 추가.
    }

    // 모든 테스트가 실행되기 전에 호출되는 콜백
    beforeAny { testCase ->
        println("beforeAny: ${testCase.name.testName} 테스트 실행 전 설정을 수행.")
        // 여기에 모든 테스트에 대한 공통 설정 작업을 추가다.
    }

    // 모든 테스트가 실행된 후에 호출되는 콜백
    afterAny { (testCase, testResult) ->
        println("afterAny:${testCase.name.testName} 테스트 실행 후 정리를 수행.")
        println("결과: $testResult")
        // 여기에 모든 테스트에 대한 공통 정리 작업을 추가.
    }

    // 각 테스트 실행 전에 호출되는 콜백
    beforeEach { testCase ->
        println("beforeEach: ${testCase.name.testName} 테스트 실행 전 설정을 수행.")
        // 여기에 테스트의 개별 설정 작업을 추가.
    }

    // 각 테스트 실행 후에 호출되는 콜백
    afterEach { (testCase, testResult) ->
        println("afterEach: ${testCase.name.testName} 테스트 실행 후 정리를 수행.")
        println("결과: $testResult")
        // 여기에 테스트의 개별 정리 작업을 추가.
    }

    // 테스트 케이스 1
    "TestCase1" {
        println("TestCase1 실행.")
        val result = 2 + 2
        result shouldBe 4
    }

    // 테스트 케이스 2
    "TestCase2" {
        println("'TestCase2' 실행.")
        val list = mutableListOf<Int>()
        list.add(1)
        list.add(2)
        list.size shouldBe 2
    }
})

다음은 위 예시를 실행한 결과이다:

beforeSpec: 스펙 실행 전 설정을 수행.
beforeEach: TestCase1 테스트 실행 전 설정을 수행.
beforeTest: TestCase1 실행 전 설정을 수행.
beforeAny: TestCase1 테스트 실행 전 설정을 수행.
TestCase1 실행.
afterAny:TestCase1 테스트 실행 후 정리를 수행. 결과: Success(duration=36ms)
afterTest: TestCase1 실행 후 정리를 수행. 결과: Success(duration=36ms)
afterEach: TestCase1 테스트 실행 후 정리를 수행. 결과: Success(duration=36ms)
beforeEach: TestCase2 테스트 실행 전 설정을 수행.
beforeTest: TestCase2 실행 전 설정을 수행.
beforeAny: TestCase2 테스트 실행 전 설정을 수행.
'TestCase2' 실행.
afterAny:TestCase2 테스트 실행 후 정리를 수행. 결과: Success(duration=1ms)
afterTest: TestCase2 실행 후 정리를 수행. 결과: Success(duration=1ms)
afterEach: TestCase2 테스트 실행 후 정리를 수행. 결과: Success(duration=1ms)
afterSpec: 스펙 실행 후 정리를 수행.

참고

Lifecycle hooks | Kotest

Lua 함수

Mon, 22 Apr 2024 01:48:00 +0900

Lua뿐만 아니라 많은 프로그래밍 언어에서 빼놓을 수 없는 개념 중 하나로 함수가 있다. 사실 지금까지 함수를 여러 번 사용하였다. 예를 들어 print도 함수이고, io.read도 함수이다. 함수는 여러 명령어를 모아 하나의 덩어리로 정의한 것이다. 같은 처리를 여러 번 하고 싶을 때는 함수를 하나 정의하고 호출하면 된다.

함수 만들기

이제 함수를 만들어 보자. 함수는 다음과 같이 정의한다.

형식

function 함수명(인수)
    처리
end

이제 두 개의 값을 인수로 전달받아 그 합을 구하는 함수를 만들어 보자.

function sum(x, y)
    return x + y
end

hoge = 10
piyo = 20

result = sum(hoge, piyo)
print(hoge .. " + " .. piyo .. " = " .. result)

실행 결과:

10 + 20 = 30

먼저 sum 함수를 사용하기 전에 함수를 정의해야 한다는 점에 유의하자. 함수에 원하는 이름을 붙이면 된다. 단, 이미 사용 중인 함수나 변수 이름은 사용하지 말아야 한다. 예를 들어, print와 같은 이름을 붙이지 않는다. 함수 이름 지정 규칙은 변수와 동일하다.

C 언어와의 차이점

- 프로토타입 선언이 없다

이제 함수를 호출할 때, 아래와 같이 하였다.

sum(hoge, piyo)

함수를 호출할 때 인수라는 것을 전달한다. 이 인수는 어떤 것일까?

위 그림은 인수의 모습을 나타낸 그림이다. 호출한 쪽의 인수를 인자(argument, 실제 인수)라고 하고, 호출받은 쪽의 인수를 매개변수(parameter, 임시 인수)라고 한다.

이 때, 인자의 값이 매개변수의 값으로 복사된다.

function func(x, y)
    x = 10
    y = 20
end

hoge = 12
piyo = 22
func(hoge, piyo)

print(hoge, piyo)

즉 위와 같이 호출하더라도 x,y는 hoge, piyo의 복사본이므로 내용을 아무리 다시 작성해도 호출 원본인 hoge, piyo에는 영향을 미치지 않는다.

인수와 관련하여, 어쩌면 아무것도 받을 필요가 없는 경우가 있을 수 있다. 이 경우, 인수를 비워두면 된다.

함수의 반환값에 대해서는 다음 장에서 설명한다.

함수의 반환값

함수에는 반환값이라는 것이 존재한다. 앞에서 설명한 프로그램과 아래 그림을 참고해보자.

return은 함수를 호출한 측에 값을 반환하는 명령어이다. 여기서 x + y의 계산 결과를 호출자에게 반환한다. 즉, 변수 result에는 계산 결과가 대입된다.

Lua는 여러 개의 값을 반환할 수 있다. 예를 들어, 다음과 같이 할 수 있다.

function func()
  return 10, 20
end

hoge, piyo = func()
print(hoge, piyo)

실행 결과:

10	20

hoge에는 10이, piyo에는 20이 대입된다.

그렇다면 다음과 같은 코드를 작성하면 어떻게 될까?

function func()
    return 10, 20
end

hoge = func()
print(hoge, piyo)

이 경우 두 번째 반환값인 20은 사용되지 않고 사라진다.

실행 결과:

10	nil

또한, 다음과 같은 코드를 작성했다면 어떨까?

function func()
    return 10
end

piyo = 20

hoge, piyo = func()

print(hoge, piyo)

두 번째 반환값은 없다. 이 경우 piyo에는 nil이 할당된다. piyo는 20이 아니므로 주의해야 한다.

실행 결과:

10	nil

아무것도 반환하지 않는 함수

반환값 함수, 즉 아무것도 반환하지 않는 함수를 만들 수도 있다. 이 경우 return을 작성하지 않아도 된다.

function func()
  print("함수가 호출되었다")
end

func()

실행 결과:

함수가 호출되었다.

또한, 명시적으로 반환값이 없음을 나타내기 위해 return만 작성할 수도 있다.

function func()
  print("함수가 호출되었다")
  return
end

func()

위의 두 코드는 완전히 동일한 코드이다.

변수에 함수 대입하기

Lua의 변수에는 어떤 값이라도 대입할 수 있다. 심지어 함수라도 대입이 가능하다. 예를 들어 다음과 같은 것도 가능하다.

function sum(x, y)
  return x + y
end

function mul(x, y)
  return x * y
end

hoge = sum
print("hoge is " .. type(hoge));
print("10 + 20 is " .. hoge(10, 20))

hoge = mul
print("10 * 20 is " .. hoge(10, 20))

type 함수는 현재 변수의 타입을 검사하는 함수이다. hoge에는 sum 함수와 mul 함수를 대입하고 있다. 그리고 hoge를 사용하여 함수에 접근할 수도 있다. C언어를 아는 사람은 함수 포인터와 같은 역할을 할 수 있다고 생각하면 된다. 실행 결과:

hoge is function
10 + 20 is 30
10 * 20 is 200

함수 안에서 함수 정의하기

Lua에서는 함수 내에서 함수를 정의할 수도 있다.

function func(x)
  local function get()
      return x
  end

  local function add(value)
      x = x + value
  end
  return get, add
end

firstGetValue, firstAddValue = func(10)
secondGetValue, secondAddValue = func(30)

print("first value : " .. firstGetValue())
print("second value : " .. secondGetValue())

firstAddValue( 15 )
secondAddValue( 20 )

print("first value : " .. firstGetValue())
print("second value : " .. secondGetValue())

func 함수는 get과 add 함수를 반환값으로 반환한다. 여기서 local이라는 새로운 키워드가 등장했다. 이 local에 대해서는 유효범위 장에서 자세히 설명한다. 간단히 설명하면, local이라는 키워드를 붙이면 로컬 변수(또는 로컬 함수)를 생성할 수 있다. 즉, get 함수도 add 함수도 func 함수 내에서만 호출할 수 있다는 뜻이다.

실행 결과:

first value : 10
second value : 30
first value : 25
second value : 50

무명 함수

이름 없는 함수를 만들 수도 있다. 예를 들어, 다음과 같은 코드를 작성할 수 있다.

function createSquare()
  return function(x)
      return x * x
  end
end

square = createSquare()
print("10 * 10 is " .. square(10, 10))

createSquare 함수는 반환값에 x * x를 하는 함수를 반환한다.

실행 결과:

10 * 10 is 100

기본 라이브러리

여기서는 기본 라이브러리에 제공되는 함수 중 일부를 소개한다.

assert 함수

정의

assert (v [, message])

assert 함수는 v가 거짓 조건일 경우 에러를 발생시키는 함수이다. message에는 에러 메시지를 전달한다. 에러 메시지는 생략할 수 있다.

hoge = true
assert(hoge, "Error #1")
hoge = false
assert(hoge, "Error #2")

실행 결과:

lua: test.lua:4: Error #2
stack traceback:
	[C]: in function 'assert'
	test.lua:4: in main chunk
	[C]: in ?

dofile 함수

정의

dofile(filename)

dofile 함수는 filename으로 지정한 파일을 실행하는 함수이다. 예를 들어 다음과 같이 사용한다. 이번에는 두 개의 Lua 파일인 test.lua와 call.lua에 코드를 작성하였다.

call.lua

function testFunc()
  print ("Hello")
  return "World!"
end

test.lua

dofile("call.lua")

hoge = testFunc()
print(hoge)

실행 결과:

Hello
World!

dofile에서 call.lua를 불러오면 test.lua 측에서 testFunc 함수를 사용할 수 있다.

type 함수

정의

type(v)

type 함수는 데이터의 타입을 반환하는 함수이다.

hoge = nil
print("hoge : " .. type(hoge))
hoge = 10
print("hoge : " .. type(hoge))
hoge = true
print("hoge : " .. type(hoge))
hoge = "Hello"
print("hoge : " .. type(hoge))

실행 결과:

hoge : nil
hoge : number
hoge : boolean
hoge : string

tonumber 함수

정의

tonumber (e [, base])

tonumber 함수는 인수 e를 숫자로 변환하는 함수이다. 숫자 변환이 가능하면 숫자를 반환하고, 그렇지 않으면 nil을 반환한다.

또한, base를 지정하면 e를 base 진법의 숫자로 변환한다. 생략하면 10이 자동으로 지정된다.

hoge = "25"
print("hoge :" .. hoge .. " type :" .. type(hoge))
piyo = tonumber(hoge)
print("piyo :" .. piyo .. " type :" .. type(piyo))

실행 결과:

hoge :25 type :string
piyo :25 type :number

tostring 함수

정의

tostring(e)

tostring 함수는 e를 문자열로 변환하는 함수이다.

hoge = 25
print("hoge :" .. hoge .. " type :" .. type(hoge))
piyo = tostring(hoge)
print("piyo :" .. piyo .. " type :" .. type(piyo))

실행 결과:

hoge :25 type :number
piyo :25 type :string

숫자를 문자열로 변환할 때는 tostring 함수를 사용하지 않고 빈 문자열을 추가해도 된다.

piyo = hoge .. ""