diff --git a/README.md b/README.md
index 8d7e8aee..16389b19 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,158 @@
-# java-baseball-precourse
\ No newline at end of file
+# 🌤️ 날씨 조회 서비스
+도시 이름을 입력받아 Open-Meteo API를 통해 실시간 날씨 정보를 조회하는 Spring 기반 웹 서비스
+
+---
+## 📌 구현 목표
+사용자가 도시 이름을 입력하면, 해당 도시의 위도·경도를 기반으로 외부 API(Open-Meteo)를 호출하여 다음 정보를 제공하는 간단한 날씨 조회 API를 구현
+
+- 현재 기온
+- 체감 온도
+- 하늘 상태(맑음, 흐림 등)
+- 습도
+- 조회된 데이터를 기반으로 한 한 줄 요약 문장
+---
+## 🏗️ 기술 스택
+- Java 21
+- Spring Web
+- Spring WebFlux (WebClient)
+- Lombok
+- JUnit5 / AssertJ / MockMvc
+- Gradle
+---
+## 📁 프로젝트 구조
+```
+src
+├── main
+│   └── java/com/llm_precourse/weather
+│       ├── controller
+│       ├── service
+│       ├── domain
+│       ├── dto
+│       ├── exception
+│       └── common
+└── test
+    └── java/com/llm_precourse/weather
+        ├── domain
+        ├── service
+        └── controller
+```
+---
+## 🚀 구현 기능
+
+### 1. 지원 도시 관리 (City enum)
+- 최소 5개 도시를 지원하며, 도시명 → 위도/경도 매핑을 Enum 형태로 모델링 
+- enum 내부에 `Map<String, City>`를 두어 도시 이름(대소문자 무시)으로 O(1)의 복잡도로 도시 정보를 조회할 수 있는 자료구조를 설계
+- 도시명 → City 매핑: `BY_NAME` (불변 Map)
+- 각 enum 상수는 `cityName`, `cityNameKr`, `latitude`, `longitude`를 보유
+- `City.from(String city)` 메서드를 통해 입력값을 정규화 후 enum 조회
+- 지원 도시:
+
+| 도시      | 위도      | 경도       |
+|---------|---------|----------|
+| Seoul   | 37.5665 | 126.9780 |
+| Tokyo   | 35.6762 | 139.6503 |
+| NewYork | 40.7128 | -74.0060 |
+| Paris   | 48.8566 | 2.3522   |
+| London  | 51.5074 | -0.1278  |
+
+### 2. 날씨 코드 매핑 (WeatherCondition enum)
+- Open-Meteo에서 내려주는 `weather_code` 값을 `WeatherCondition` enum으로 모델링
+- 각 enum 상수는 `code`(정수 코드)와 `description`(한글 설명)을 가지며, 내부 `Map<Integer, WeatherCondition>`을 통해 상수 조회
+- weather_code → WeatherCondition 매핑: `BY_CODE` (불변 Map)
+- `WeatherCondition.descriptionOf(int code)`를 통해 문자열 반환
+
+### 3. 외부 API 연동 (OpenMeteoClient)
+Spring WebFlux의 WebClient 를 사용하여 Open-Meteo API 호출.
+> e.g. https://api.open-meteo.com/v1/forecast?latitude={lat}&longitude={lon}&current_weather=true
+- 조회 필드:
+    - temperature_2m
+    - apparent_temperature
+    - relative_humidity_2m
+    - weather_code
+
+### 4. WeatherService (핵심 비즈니스 로직)
+- 담당 기능:
+    - 도시명 검증
+    - 위도/경도 기반 날씨 조회
+    - 하늘 상태(weather_code → 한글 설명) 변환
+    - 최종 사용자 응답 DTO 생성
+    - 자연스러운 한 줄 요약 문장 생성
+> 예시: “현재 서울의 기온은 3.4℃이고, 체감 온도는 1.2℃입니다. 하늘 상태는 흐림이며, 습도는 65%입니다.”
+
+### 5. 도시별 날씨 조회 API
+`GET /api/weather?city={cityName}`
+- 응답(JSON)
+```
+  {
+  "city": "Seoul",
+  "temperature": 3.4,
+  "feelsLike": 1.2,
+  "condition": "부분적으로 흐림",
+  "humidity": 65,
+  "summary": "현재 서울의 기온은 3.4℃이고, 체감 온도는 1.2℃입니다. 하늘 상태는 부분적으로 흐림이며, 습도는 65%입니다."
+  }
+```
+---
+## ⚠️ 에러 처리(예외 전략)
+중앙 집중 방식(GlobalExceptionHandler) 적용.
+
+| 상황                        | HTTP Status               | Error code            | message                    |
+|---------------------------|---------------------------|-----------------------|----------------------------|
+| 입력 파라미터 누락/빈 값            | 400 Bad Request           | INVALID_REQUEST       | city 파라미터는 필수입니다.          |
+| 지원하지 않는 도시명               | 400 Bad Request           | CITY_NOT_SUPPORTED    | 지원하지 않는 도시입니다.             |
+| Open-Meteo API 호출 실패/타임아웃 | 502 Bad Gateway           | EXTERNAL_API_ERROR    | 외부 날씨 API 호출 중 오류가 발생했습니다. |
+| 그 외 예상치 못한 서버 내부 오류       | 500 Internal Server Error | INTERNAL_SERVER_ERROR | 알 수 없는 오류가 발생했습니다.         |
+
+- JSON Sample
+```
+{
+"code": "CITY_NOT_SUPPORTED",
+"message": "지원하지 않는 도시입니다.",
+"timestamp": "2025-01-01T12:00:00"
+}
+```
+---
+## 🧪 테스트 전략
+테스트는 총 3단계로 구성됨.
+
+### 1단계 — 단위 테스트 (Domain)
+- 대상: City.from()
+- 검증 내용:
+    - 정상 도시 매핑
+    - 대소문자 무시
+    - null / 빈 문자열 처리
+    - 미지원 도시 처리
+- 파일: `CityTest.java`
+
+### 2단계 — 단위 테스트 (Service)
+- 대상: WeatherService
+- FakeOpenMeteoClient 를 사용하여 외부 API 의존성 제거
+- 검증내용:
+    - 요약 문장 생성 로직 검증
+    - 예외 처리 검증
+- 파일: `WeatherServiceTest.java`
+
+### 3단계 — Controller 테스트 (API Endpoint)
+- 도구: MockMvc + @WebMvcTest
+- 검증 내용:
+    - 정상 요청 시 200 OK + WeatherResponse 반환
+    - 잘못된 city 입력 시 400 INVALID_REQUEST
+    - 미지원 도시 요청 시 400 CITY_NOT_SUPPORTED
+    - 외부 API 에러 시 502 EXTERNAL_API_ERROR
+- 파일: `WeatherControllerTest.java`
+---
+## 🤖 AI 활용 방식
+- 기능 및 프로그래밍 요구사항을 AI 도구에 제공한 뒤, 소스 코드·테스트 코드·README.md 초안 생성을 요청함
+- 생성된 코드를 검토하며 요구사항과 맞지 않는 부분을 지적하고, 필요한 리팩토링을 재요청함
+- AI가 생성한 README 초안을 바탕으로 전체 문서 구조를 재정리하고, Markdown 표현 방식(bullet → table 등)을 개선함
+- 생성된 테스트 코드를 직접 실행하여 통과 여부를 확인하고, 실패한 테스트에 대해 AI에게 디버깅을 요청함
+- 코드/테스트/README 생성에 사용된 AI의 접근 방식과 설명을 참고하며, 이해가 필요한 부분은 별도로 질문함
+- 리팩토링 및 디버깅 과정에서도 AI가 제시한 설명을 기반으로 추가 질문을 하며 내용을 보완함
+- 본 섹션(AI 활용 방식, Lessons Learned)의 문장 표현 역시 AI에게 자연스럽게 다듬어 달라고 요청함
+
+## 📘 Lessons Learned
+- AI 도구를 활용하면 요구사항을 빠르고 효율적으로 구현할 수 있음을 체감함
+- 그럼에도 결과물의 품질을 완전히 보장하려면, 사람의 검토와 판단이 여전히 필요한 부분도 있음
+- AI가 생성한 산출물을 다시 AI에게 검증·보완시키는 자동화된 품질 관리 파이프라인을 구축하면 생산성이 더욱 높아질 것이라 판단함
+- 여러 AI 도구가 서로 보완적으로 협력하는 파이프라인을 구축한다면, 결과물의 품질을 더욱 높일 수 있을 것이라 기대함
+- AI는 인간의 역량을 확장시키는 도구이며, 이를 통해 더 많은 문제를 해결할 수 있다는 가능성을 확인함
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
index 20a92c9e..3778465f 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,5 +1,7 @@
 plugins {
     id 'java'
+    id("org.springframework.boot") version "3.5.8"
+    id("io.spring.dependency-management") version "1.1.7"
 }
 
 group = 'camp.nextstep.edu'
@@ -7,7 +9,7 @@ version = '1.0-SNAPSHOT'
 
 java {
     toolchain {
-        languageVersion = JavaLanguageVersion.of(17)
+        languageVersion = JavaLanguageVersion.of(21)
     }
 }
 
@@ -16,6 +18,18 @@ repositories {
 }
 
 dependencies {
+    implementation 'org.springframework.boot:spring-boot-starter-web:3.5.8'
+    implementation 'org.springframework.boot:spring-boot-starter-webflux:3.5.8'
+
+    implementation(platform("org.springframework.ai:spring-ai-bom:1.1.2"))
+    implementation("org.springframework.ai:spring-ai-starter-model-google-genai")
+
+    compileOnly 'org.projectlombok:lombok'
+    annotationProcessor 'org.projectlombok:lombok'
+    testCompileOnly 'org.projectlombok:lombok'
+    testAnnotationProcessor 'org.projectlombok:lombok'
+
+    testImplementation 'org.springframework.boot:spring-boot-starter-test:3.5.8'
     testImplementation 'org.junit.jupiter:junit-jupiter:5.10.2'
     testImplementation 'org.assertj:assertj-core:3.25.3'
 }
diff --git a/settings.gradle b/settings.gradle
index 11c425be..b86a01f0 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,4 +1,4 @@
-plugins {
-    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.7.0'
-}
+//plugins {
+//    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.7.0'
+//}
 rootProject.name = 'java-baseball'
diff --git a/src/main/java/com/llm_precourse/weather/WeatherApplication.java b/src/main/java/com/llm_precourse/weather/WeatherApplication.java
new file mode 100644
index 00000000..7d9bfc58
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/WeatherApplication.java
@@ -0,0 +1,13 @@
+package com.llm_precourse.weather;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class WeatherApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(WeatherApplication.class, args);
+    }
+
+}
diff --git a/src/main/java/com/llm_precourse/weather/common/GlobalExceptionHandler.java b/src/main/java/com/llm_precourse/weather/common/GlobalExceptionHandler.java
new file mode 100644
index 00000000..a4814ad7
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/common/GlobalExceptionHandler.java
@@ -0,0 +1,65 @@
+package com.llm_precourse.weather.common;
+
+import com.llm_precourse.weather.dto.ErrorResponse;
+import com.llm_precourse.weather.exception.ExternalApiException;
+import com.llm_precourse.weather.exception.InvalidRequestException;
+import com.llm_precourse.weather.exception.UnsupportedCityException;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+
+import jakarta.servlet.http.HttpServletRequest;
+import java.time.LocalDateTime;
+
+@RestControllerAdvice
+public class GlobalExceptionHandler {
+
+    @ExceptionHandler(InvalidRequestException.class)
+    public ResponseEntity<ErrorResponse> handleInvalidRequest(InvalidRequestException ex,
+            HttpServletRequest request) {
+        ErrorResponse body = ErrorResponse.builder()
+                .code("INVALID_REQUEST")
+                .message(ex.getMessage())
+                .timestamp(LocalDateTime.now())
+                .path(request.getRequestURI())
+                .build();
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(body);
+    }
+
+    @ExceptionHandler(UnsupportedCityException.class)
+    public ResponseEntity<ErrorResponse> handleUnsupportedCity(UnsupportedCityException ex,
+            HttpServletRequest request) {
+        ErrorResponse body = ErrorResponse.builder()
+                .code("CITY_NOT_SUPPORTED")
+                .message(ex.getMessage())
+                .timestamp(LocalDateTime.now())
+                .path(request.getRequestURI())
+                .build();
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(body);
+    }
+
+    @ExceptionHandler(ExternalApiException.class)
+    public ResponseEntity<ErrorResponse> handleExternalApi(ExternalApiException ex,
+            HttpServletRequest request) {
+        ErrorResponse body = ErrorResponse.builder()
+                .code("EXTERNAL_API_ERROR")
+                .message(ex.getMessage())
+                .timestamp(LocalDateTime.now())
+                .path(request.getRequestURI())
+                .build();
+        return ResponseEntity.status(HttpStatus.BAD_GATEWAY).body(body);
+    }
+
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<ErrorResponse> handleGeneric(Exception ex,
+            HttpServletRequest request) {
+        ErrorResponse body = ErrorResponse.builder()
+                .code("INTERNAL_SERVER_ERROR")
+                .message("알 수 없는 오류가 발생했습니다. 잠시 후 다시 시도해 주세요.")
+                .timestamp(LocalDateTime.now())
+                .path(request.getRequestURI())
+                .build();
+        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(body);
+    }
+}
diff --git a/src/main/java/com/llm_precourse/weather/common/OpenMeteoClient.java b/src/main/java/com/llm_precourse/weather/common/OpenMeteoClient.java
new file mode 100644
index 00000000..be4832c9
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/common/OpenMeteoClient.java
@@ -0,0 +1,32 @@
+package com.llm_precourse.weather.common;
+
+import com.llm_precourse.weather.dto.OpenMeteoResponse;
+import com.llm_precourse.weather.exception.ExternalApiException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.client.WebClient;
+
+@Component
+@RequiredArgsConstructor
+public class OpenMeteoClient {
+
+    private final WebClient webClient;
+
+    public OpenMeteoResponse getCurrentWeather(double latitude, double longitude) {
+        try {
+            return webClient.get()
+                    .uri(uriBuilder -> uriBuilder
+                            .path("/forecast")
+                            .queryParam("latitude", latitude)
+                            .queryParam("longitude", longitude)
+                            .queryParam("current",
+                                    "temperature_2m,apparent_temperature,relative_humidity_2m,weather_code")
+                            .build())
+                    .retrieve()
+                    .bodyToMono(OpenMeteoResponse.class)
+                    .block();
+        } catch (Exception e) {
+            throw new ExternalApiException("외부 날씨 API 호출 중 오류가 발생했습니다.", e);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/llm_precourse/weather/common/WebClientConfig.java b/src/main/java/com/llm_precourse/weather/common/WebClientConfig.java
new file mode 100644
index 00000000..e617238a
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/common/WebClientConfig.java
@@ -0,0 +1,16 @@
+package com.llm_precourse.weather.common;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.reactive.function.client.WebClient;
+
+@Configuration
+public class WebClientConfig {
+
+    @Bean
+    public WebClient openMeteoWebClient() {
+        return WebClient.builder()
+                .baseUrl("https://api.open-meteo.com/v1")
+                .build();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/llm_precourse/weather/controller/WeatherController.java b/src/main/java/com/llm_precourse/weather/controller/WeatherController.java
new file mode 100644
index 00000000..2001828d
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/controller/WeatherController.java
@@ -0,0 +1,25 @@
+package com.llm_precourse.weather.controller;
+
+import com.llm_precourse.weather.dto.WeatherResponse;
+import com.llm_precourse.weather.service.WeatherService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequiredArgsConstructor
+public class WeatherController {
+
+    private final WeatherService weatherService;
+
+    @GetMapping("/api/weather/v1")
+    public WeatherResponse getWeather(@RequestParam("city") String city) {
+        return weatherService.getWeather(city);
+    }
+
+    @GetMapping("/api/weather/v2")
+    public WeatherResponse getWeatherByLlm(@RequestParam("city") String city) {
+        return weatherService.getWeatherByLlm(city);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/llm_precourse/weather/domain/City.java b/src/main/java/com/llm_precourse/weather/domain/City.java
new file mode 100644
index 00000000..64bb767f
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/domain/City.java
@@ -0,0 +1,39 @@
+package com.llm_precourse.weather.domain;
+
+import java.util.Locale;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Arrays;
+
+@Getter
+@RequiredArgsConstructor
+public enum City {
+    SEOUL("Seoul", "서울", 37.5665, 126.9780),
+    TOKYO("Tokyo", "도쿄", 35.6762, 139.6503),
+    NEW_YORK("NewYork", "뉴욕", 40.7128, -74.0060),
+    PARIS("Paris", "파리", 48.8566, 2.3522),
+    LONDON("London", "런던", 51.5074, -0.1278);
+
+    private static final Map<String, City> BY_NAME =
+            Arrays.stream(values())
+                    .collect(
+                            Collectors.toUnmodifiableMap(
+                                    city -> city.cityName.toLowerCase(Locale.ROOT), Function.identity()));
+
+    private final String cityName;
+    private final String cityNameKr;
+    private final double latitude;
+    private final double longitude;
+
+    public static City from(String city) {
+        if (city == null) {
+            return null;
+        }
+        String normalized = city.trim().toLowerCase(Locale.ROOT);
+        return BY_NAME.get(normalized);
+    }
+}
diff --git a/src/main/java/com/llm_precourse/weather/domain/GeoInfo.java b/src/main/java/com/llm_precourse/weather/domain/GeoInfo.java
new file mode 100644
index 00000000..8360efc3
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/domain/GeoInfo.java
@@ -0,0 +1,11 @@
+package com.llm_precourse.weather.domain;
+
+import lombok.Data;
+
+@Data
+public class GeoInfo {
+
+    private final double latitude;
+    private final double longitude;
+
+}
diff --git a/src/main/java/com/llm_precourse/weather/domain/WeatherCondition.java b/src/main/java/com/llm_precourse/weather/domain/WeatherCondition.java
new file mode 100644
index 00000000..4b08ec69
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/domain/WeatherCondition.java
@@ -0,0 +1,51 @@
+package com.llm_precourse.weather.domain;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public enum WeatherCondition {
+
+    CLEAR(0, "맑음"),
+    PARTLY_CLOUDY_1(1, "부분적으로 흐림"),
+    PARTLY_CLOUDY_2(2, "부분적으로 흐림"),
+    PARTLY_CLOUDY_3(3, "부분적으로 흐림"),
+    FOG_45(45, "안개"),
+    FOG_48(48, "안개"),
+    DRIZZLE_51(51, "이슬비"),
+    DRIZZLE_53(53, "이슬비"),
+    DRIZZLE_55(55, "이슬비"),
+    RAIN_61(61, "비"),
+    RAIN_63(63, "비"),
+    RAIN_65(65, "비"),
+    SNOW_71(71, "눈"),
+    SNOW_73(73, "눈"),
+    SNOW_75(75, "눈"),
+    SHOWER_80(80, "소나기"),
+    SHOWER_81(81, "소나기"),
+    SHOWER_82(82, "소나기"),
+    THUNDERSTORM_95(95, "뇌우"),
+    UNKNOWN(-1, "알 수 없음");
+
+    private static final Map<Integer, WeatherCondition> BY_CODE =
+            Arrays.stream(values())
+                    .collect(
+                            Collectors.toUnmodifiableMap(
+                                    WeatherCondition::getCode, Function.identity(), (first, second) -> second));
+
+    private final int code;
+    private final String description;
+
+    public static String descriptionOf(int code) {
+        WeatherCondition condition = BY_CODE.get(code);
+        if (condition == null) {
+            return UNKNOWN.description;
+        }
+        return condition.description;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/llm_precourse/weather/dto/Clothing.java b/src/main/java/com/llm_precourse/weather/dto/Clothing.java
new file mode 100644
index 00000000..7a170f5e
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/dto/Clothing.java
@@ -0,0 +1,30 @@
+package com.llm_precourse.weather.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class Clothing {
+
+    // 결과를 담는 DTO 클래스
+    private final Double temperature;   // 실제 기온 (섭씨, nullable)
+    private final Double feelsLike;     // 체감온도 (섭씨, nullable)
+    private final String top;           // 상의
+    private final String bottom;        // 하의
+    private final String outer;         // 겉옷
+    private final String accessories;   // 액세서리/기타
+    private final String message;       // 추가 메시지
+
+
+    @Override
+    public String toString() {
+        return "현재 기온: " + temperature + "°C, 체감온도: " + feelsLike + "°C\n"
+                + "[상의] " + top + "\n"
+                + "[하의] " + bottom + "\n"
+                + "[겉옷] " + outer + "\n"
+                + "[액세서리] " + accessories + "\n"
+                + "[메시지] " + message;
+    }
+
+}
diff --git a/src/main/java/com/llm_precourse/weather/dto/ErrorResponse.java b/src/main/java/com/llm_precourse/weather/dto/ErrorResponse.java
new file mode 100644
index 00000000..dd59596b
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/dto/ErrorResponse.java
@@ -0,0 +1,17 @@
+package com.llm_precourse.weather.dto;
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.time.LocalDateTime;
+
+@Getter
+@Builder
+public class ErrorResponse {
+
+    private final String code;
+    private final String message;
+    private final LocalDateTime timestamp;
+    private final String path;
+
+}
diff --git a/src/main/java/com/llm_precourse/weather/dto/OpenMeteoResponse.java b/src/main/java/com/llm_precourse/weather/dto/OpenMeteoResponse.java
new file mode 100644
index 00000000..959907a5
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/dto/OpenMeteoResponse.java
@@ -0,0 +1,39 @@
+package com.llm_precourse.weather.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+public class OpenMeteoResponse {
+
+    @JsonProperty("latitude")
+    private double latitude;
+
+    @JsonProperty("longitude")
+    private double longitude;
+
+    @JsonProperty("current")
+    private Current current;
+
+    @Getter
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class Current {
+
+        @JsonProperty("temperature_2m")
+        private double temperature;
+
+        @JsonProperty("apparent_temperature")
+        private double apparentTemperature;
+
+        @JsonProperty("relative_humidity_2m")
+        private double humidity;
+
+        @JsonProperty("weather_code")
+        private int weatherCode;
+    }
+}
diff --git a/src/main/java/com/llm_precourse/weather/dto/WeatherResponse.java b/src/main/java/com/llm_precourse/weather/dto/WeatherResponse.java
new file mode 100644
index 00000000..9e71b069
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/dto/WeatherResponse.java
@@ -0,0 +1,20 @@
+package com.llm_precourse.weather.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+@AllArgsConstructor
+public class WeatherResponse {
+
+    private final String city;
+    private final double temperature;
+    private final double feelsLike;
+    private final String condition;
+    private final double humidity;
+    private final String summary;
+
+    private final String recommendedClothes;
+}
diff --git a/src/main/java/com/llm_precourse/weather/exception/ExternalApiException.java b/src/main/java/com/llm_precourse/weather/exception/ExternalApiException.java
new file mode 100644
index 00000000..48ffbff2
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/exception/ExternalApiException.java
@@ -0,0 +1,8 @@
+package com.llm_precourse.weather.exception;
+
+import lombok.experimental.StandardException;
+
+@StandardException
+public class ExternalApiException extends RuntimeException {
+
+}
\ No newline at end of file
diff --git a/src/main/java/com/llm_precourse/weather/exception/InvalidInputException.java b/src/main/java/com/llm_precourse/weather/exception/InvalidInputException.java
new file mode 100644
index 00000000..e205be26
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/exception/InvalidInputException.java
@@ -0,0 +1,7 @@
+package com.llm_precourse.weather.exception;
+
+import lombok.experimental.StandardException;
+
+@StandardException
+public class InvalidInputException extends RuntimeException {
+}
diff --git a/src/main/java/com/llm_precourse/weather/exception/InvalidRequestException.java b/src/main/java/com/llm_precourse/weather/exception/InvalidRequestException.java
new file mode 100644
index 00000000..687a25b3
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/exception/InvalidRequestException.java
@@ -0,0 +1,8 @@
+package com.llm_precourse.weather.exception;
+
+import lombok.experimental.StandardException;
+
+@StandardException
+public class InvalidRequestException extends RuntimeException {
+
+}
diff --git a/src/main/java/com/llm_precourse/weather/exception/UnsupportedCityException.java b/src/main/java/com/llm_precourse/weather/exception/UnsupportedCityException.java
new file mode 100644
index 00000000..7fda088a
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/exception/UnsupportedCityException.java
@@ -0,0 +1,8 @@
+package com.llm_precourse.weather.exception;
+
+import lombok.experimental.StandardException;
+
+@StandardException
+public class UnsupportedCityException extends RuntimeException {
+
+}
\ No newline at end of file
diff --git a/src/main/java/com/llm_precourse/weather/service/WeatherService.java b/src/main/java/com/llm_precourse/weather/service/WeatherService.java
new file mode 100644
index 00000000..01a7c59b
--- /dev/null
+++ b/src/main/java/com/llm_precourse/weather/service/WeatherService.java
@@ -0,0 +1,334 @@
+package com.llm_precourse.weather.service;
+
+import com.llm_precourse.weather.common.OpenMeteoClient;
+import com.llm_precourse.weather.domain.City;
+import com.llm_precourse.weather.domain.WeatherCondition;
+import com.llm_precourse.weather.dto.Clothing;
+import com.llm_precourse.weather.dto.OpenMeteoResponse;
+import com.llm_precourse.weather.dto.WeatherResponse;
+import com.llm_precourse.weather.exception.InvalidInputException;
+import com.llm_precourse.weather.exception.InvalidRequestException;
+import com.llm_precourse.weather.exception.UnsupportedCityException;
+import java.util.Map;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.chat.client.ChatClient;
+import org.springframework.ai.chat.prompt.Prompt;
+import org.springframework.ai.chat.prompt.PromptTemplate;
+import org.springframework.ai.chat.prompt.SystemPromptTemplate;
+import org.springframework.ai.converter.BeanOutputConverter;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+import com.llm_precourse.weather.domain.GeoInfo;
+
+@Service
+@Slf4j
+public class WeatherService {
+
+    private final OpenMeteoClient openMeteoClient;
+    private final ChatClient client;
+
+    public WeatherService(OpenMeteoClient openMeteoClient, ChatClient.Builder builder) {
+        this.openMeteoClient = openMeteoClient;
+        this.client = builder.build();
+    }
+    //private ChatClient client = ChatClient.Builder.build();
+
+    public WeatherResponse getWeather(String city) {
+        validateCityParameter(city);
+
+        City supportedCity = resolveSupportedCity(city);
+        OpenMeteoResponse response = fetchWeather(supportedCity);
+        OpenMeteoResponse.Current current = extractCurrentWeather(response);
+
+        return buildWeatherResponse(supportedCity, current);
+    }
+
+    public WeatherResponse getWeatherByLlm(String query) {
+        //query의 종류는 도시/구/군/권역 등
+        validateCityParameter(query);
+        try {
+            return this.getWeather(query);
+        } catch(UnsupportedCityException uce) {
+            log.info("DB에 없는 도시입니다.");
+        }
+
+        GeoInfo geoInfo = resolveSupportedCityByLlm(query);
+
+        OpenMeteoResponse response = fetchWeather(geoInfo);
+
+        OpenMeteoResponse.Current current = extractCurrentWeather(response);
+
+        return buildWeatherResponseWithRecommendClothing(current, query);
+    }
+
+    private void validateCityParameter(String city) {
+        if (!StringUtils.hasText(city)) {
+            throw new InvalidRequestException("city 파라미터는 필수입니다.");
+        }
+    }
+
+    private City resolveSupportedCity(String city) {
+        City supportedCity = City.from(city);
+        if (supportedCity == null) {
+            throw new UnsupportedCityException(
+                    "지원하지 않는 도시입니다. (Seoul, Tokyo, NewYork, Paris, London만 지원)");
+        }
+        return supportedCity;
+    }
+
+    private GeoInfo resolveSupportedCityByLlm(String query) {
+        var beanOutputConverter = new BeanOutputConverter<>(GeoInfo.class);
+        var format = beanOutputConverter.getFormat();
+        log.info(format);
+        var systemPromptTemplate = new SystemPromptTemplate("""
+                You are a geocoding assistant.
+                Goal:
+                 - The user provides a city name, region name, or similar location descriptor.
+                 - You must respond with the geographic coordinates (latitude and longitude) of that location.
+                Rules:
+                - latitude, longitude 필드는 반드시 숫자 타입이어야 한다 (문자열 X).
+                - 한국어를 기본 언어로 사용하되, 국가명 등은 필요하다면 영어로 쓸 수 있다.
+                Ambiguity:
+                - If the input is ambiguous (e.g., "Paris"), and you choose the most common one (e.g., Paris, France), fill "note" with a short explanation in Korean (e.g., "가장 일반적인 파리(프랑스 기준)로 가정했습니다.").
+                """);
+        var userStr = """
+            {query}의 위치이름, 위도, 경도를 알려줘.
+            {format}
+            """;
+
+        var system = systemPromptTemplate.createMessage();
+        var userMessage = new PromptTemplate(userStr).createMessage(Map.of("query", query, "format", format));
+        var prompt = new Prompt(userMessage, system);
+
+        var chatResponse = client.prompt(prompt).call().chatResponse();
+        var usage = chatResponse.getMetadata().getUsage();
+        var promptTokens = usage.getPromptTokens();
+        var completionTokens = usage.getCompletionTokens();
+        var totalTokens = usage.getTotalTokens();
+        var text = chatResponse.getResult().getOutput().getText();
+
+        log.info(">> Prompt Tokens = {}", promptTokens);
+        log.info(">> Completion Tokens = {}", completionTokens);
+        log.info(">> Total Tokens = {}", totalTokens);
+        log.info(">> Output Text = {}", text);
+
+        GeoInfo geoInfo =  beanOutputConverter.convert(text);
+
+        if (geoInfo == null) {
+            throw new UnsupportedCityException(
+                    "지원하지 않는 도시입니다. (Seoul, Tokyo, NewYork, Paris, London만 지원)");
+        }
+        return geoInfo;
+    }
+
+    private OpenMeteoResponse fetchWeather(City supportedCity) {
+        OpenMeteoResponse response =
+                openMeteoClient.getCurrentWeather(
+                        supportedCity.getLatitude(), supportedCity.getLongitude());
+
+        if (response == null || response.getCurrent() == null) {
+            throw new UnsupportedCityException("날씨 정보를 조회할 수 없습니다.");
+        }
+        return response;
+    }
+
+    private OpenMeteoResponse fetchWeather(GeoInfo geoInfo) {
+        OpenMeteoResponse response =
+                openMeteoClient.getCurrentWeather(
+                        geoInfo.getLatitude(), geoInfo.getLongitude());
+
+        if (response == null || response.getCurrent() == null) {
+            throw new UnsupportedCityException("날씨 정보를 조회할 수 없습니다.");
+        }
+        return response;
+    }
+
+    private OpenMeteoResponse.Current extractCurrentWeather(OpenMeteoResponse response) {
+        return response.getCurrent();
+    }
+
+    private WeatherResponse buildWeatherResponse(
+            City supportedCity, OpenMeteoResponse.Current current) {
+
+        double temperature = current.getTemperature();
+        double feelsLike = current.getApparentTemperature();
+        double humidity = current.getHumidity();
+        int weatherCode = current.getWeatherCode();
+        String conditionKr = WeatherCondition.descriptionOf(weatherCode);
+
+        String summary =
+                String.format(
+                        "현재 %s의 기온은 %.1f℃이고, 체감 온도는 %.1f℃입니다. 하늘 상태는 %s이며, 습도는 %.0f%%입니다.",
+                        supportedCity.getCityNameKr(), temperature, feelsLike, conditionKr, humidity);
+
+        return WeatherResponse.builder()
+                .city(supportedCity.getCityName())
+                .temperature(temperature)
+                .feelsLike(feelsLike)
+                .condition(conditionKr)
+                .humidity(humidity)
+                .summary(summary)
+                .build();
+    }
+
+    private WeatherResponse buildWeatherResponseWithRecommendClothing(OpenMeteoResponse.Current current, String locationName) {
+
+        double temperature = current.getTemperature();
+        double feelsLike = current.getApparentTemperature();
+        double humidity = current.getHumidity();
+        int weatherCode = current.getWeatherCode();
+        String conditionKr = WeatherCondition.descriptionOf(weatherCode);
+
+        String summary =
+                String.format(
+                        "현재 %s의 기온은 %.1f℃이고, 체감 온도는 %.1f℃입니다. 하늘 상태는 %s이며, 습도는 %.0f%%입니다.",
+                        locationName, temperature, feelsLike, conditionKr, humidity);
+
+        Clothing recommendedClothing = recommendClothing(temperature, feelsLike);
+
+        String recommend =
+                String.format(
+                        "오늘 체감온도와 기온에 따라 외투는 %s, 상의는 %s, 하의는 %s 추천드려요.\n* %s",
+                        recommendedClothing.getOuter(), recommendedClothing.getTop(), recommendedClothing.getBottom(), recommendedClothing.getMessage());
+
+        return WeatherResponse.builder()
+                .city(locationName)
+                .temperature(temperature)
+                .feelsLike(feelsLike)
+                .condition(conditionKr)
+                .humidity(humidity)
+                .summary(summary)
+                .recommendedClothes(recommend)
+                .build();
+    }
+
+    /**
+     * 체감온도(feelsLike)를 기준으로 기본 복장을 추천
+     */
+    private static String[] baseOutfitByFeelsLike(double feelsLike) {
+        String top;
+        String bottom;
+        String outer;
+        String accessories;
+
+        // 매우 추움 (체감온도 ≤ -5°C)
+        if (feelsLike <= -5) {
+            top = "두꺼운 니트 또는 기모 이너 + 티셔츠";
+            bottom = "기모 바지 또는 두꺼운 슬랙스";
+            outer = "두꺼운 롱패딩 또는 헤비 코트";
+            accessories = "목도리, 장갑, 귀마개, 두꺼운 양말";
+        }
+        // 추움 (-4°C ~ 3°C)
+        else if (feelsLike >= -4 && feelsLike <= 3) {
+            top = "니트 또는 후드티 + 이너티";
+            bottom = "기모 바지 또는 두께감 있는 바지";
+            outer = "패딩 또는 두꺼운 코트";
+            accessories = "장갑, 목도리(추위를 잘 타면), 따뜻한 양말";
+        }
+        // 쌀쌀함 (4°C ~ 9°C)
+        else if (feelsLike >= 4 && feelsLike <= 9) {
+            top = "니트, 맨투맨, 셔츠 + 가디건 중 택1";
+            bottom = "일반 두께의 청바지 또는 슬랙스";
+            outer = "울 코트, 점퍼, 가벼운 패딩 중 택1";
+            accessories = "필요시 목도리, 얇은 양말";
+        }
+        // 선선함 (10°C ~ 16°C)
+        else if (feelsLike >= 10 && feelsLike <= 16) {
+            top = "얇은 니트, 가디건, 맨투맨";
+            bottom = "청바지, 슬랙스 등 일반 바지";
+            outer = "트렌치코트, 바람막이, 얇은 점퍼 중 택1";
+            accessories = "겉옷은 상황에 따라 선택";
+        }
+        // 적당함 (17°C ~ 22°C)
+        else if (feelsLike >= 17 && feelsLike <= 22) {
+            top = "긴팔 티, 얇은 셔츠, 얇은 가디건";
+            bottom = "청바지, 슬랙스, 롱스커트 등";
+            outer = "겉옷은 얇은 가디건 정도만 선택적으로";
+            accessories = "실내 에어컨을 고려해 얇은 겉옷 하나 챙기기 좋음";
+        }
+        // 따뜻함 (23°C ~ 26°C)
+        else if (feelsLike >= 23 && feelsLike <= 26) {
+            top = "반팔 티, 얇은 셔츠, 원피스";
+            bottom = "얇은 바지나 스커트";
+            outer = "대부분 불필요, 아주 얇은 셔츠 정도";
+            accessories = "햇빛이 강하면 모자, 선크림";
+        }
+        // 더움 (27°C ~ 29°C)
+        else if (feelsLike >= 27 && feelsLike <= 29) {
+            top = "반팔 또는 민소매";
+            bottom = "반바지, 얇은 원피스";
+            outer = "불필요";
+            accessories = "통풍 잘 되는 소재(린넨, 면), 선크림, 모자";
+        }
+        // 매우 더움 (체감온도 ≥ 30°C)
+        else {
+            top = "아주 얇은 반팔 또는 민소매";
+            bottom = "반바지, 얇은 스커트/원피스";
+            outer = "불필요";
+            accessories = "모자, 선글라스, 선크림, 충분한 수분 섭취";
+        }
+
+        return new String[]{top, bottom, outer, accessories};
+    }
+
+    /**
+     * 온도/체감온도를 입력받아 복장을 추천하는 메인 메소드
+     */
+    private static Clothing recommendClothing(
+            Double temperature,   // 실제 기온 (nullable)
+            Double feelsLike      // 체감온도 (nullable)
+    ) {
+        // 온도 정보가 전혀 없을 때
+        if (temperature == null && feelsLike == null) {
+            throw new InvalidInputException("기온 또는 체감온도를 입력하면 복장을 추천해 드릴 수 있습니다.");
+        }
+
+        // 비현실적인 값 체크 (선택적으로 조정 가능)
+        Double[] values = {temperature, feelsLike};
+        for (Double v : values) {
+            if (v != null && (v < -60 || v > 60)) {
+                throw new InvalidInputException("입력된 온도가 비현실적인 값 같습니다. 섭씨(°C) 기준으로 다시 입력해 주세요.");
+            }
+        }
+
+        // 체감온도 우선, 없으면 실제 기온 사용
+        double usedFeelsLike = (feelsLike != null) ? feelsLike : temperature;
+
+        String[] baseOutfit = baseOutfitByFeelsLike(usedFeelsLike);
+        String top = baseOutfit[0];
+        String bottom = baseOutfit[1];
+        String outer = baseOutfit[2];
+        String accessories = baseOutfit[3];
+
+        // 실제 기온 vs 체감온도 차이에 대한 메시지
+        String tempDiffMsg = "";
+        if (temperature != null && feelsLike != null) {
+            double diff = feelsLike - temperature;
+            if (Math.abs(diff) >= 3) {
+                String direction = diff < 0 ? "더 춥게" : "더 덥게";
+                tempDiffMsg = String.format(
+                        "실제 기온보다 체감온도가 약 %.1f°C 정도 %s 느껴질 수 있습니다. 복장은 체감온도 기준으로 추천했습니다.",
+                        Math.abs(diff), direction
+                );
+            }
+        }
+
+        String message;
+        if (tempDiffMsg.isEmpty()) {
+            message = "체감온도를 기준으로 일상적인 복장을 추천했습니다.";
+        } else {
+            message = tempDiffMsg;
+        }
+
+        return new Clothing(
+                temperature,
+                feelsLike,
+                top,
+                bottom,
+                outer,
+                accessories,
+                message
+        );
+    }
+
+}
diff --git a/src/main/java/study/Application.java b/src/main/java/study/Application.java
new file mode 100644
index 00000000..b9e813e7
--- /dev/null
+++ b/src/main/java/study/Application.java
@@ -0,0 +1,14 @@
+package study;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+//@SpringBootApplication
+public class Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(Application.class, args);
+    }
+
+
+}
diff --git a/src/main/java/study/common/Functions.java b/src/main/java/study/common/Functions.java
new file mode 100644
index 00000000..a43ad109
--- /dev/null
+++ b/src/main/java/study/common/Functions.java
@@ -0,0 +1,30 @@
+package study.common;
+
+import java.time.LocalDate;
+import lombok.NoArgsConstructor;
+import org.springframework.ai.tool.annotation.Tool;
+import org.springframework.context.annotation.Configuration;
+import study.dto.AddDayRequest;
+import study.dto.DateResponse;
+
+@Configuration
+@NoArgsConstructor
+public class Functions {
+
+    /*@Bean
+    @Description("Calculate a date after adding days from today")
+    public Function<AddDayRequest, DateResponse> addDaysFromToday() {
+        return request -> {
+            LocalDate result = LocalDate.now().plusDays(request.days());
+            return new DateResponse(result.toString());
+        };
+    }*/
+
+    @Tool(description = "Calculate a date after adding days from today")
+    public DateResponse addDaysFromToday(AddDayRequest request) {
+        var result= LocalDate.now().plusDays(request.days());
+        return new DateResponse(result.toString());
+    }
+
+}
+
diff --git a/src/main/java/study/controller/JokeController.java b/src/main/java/study/controller/JokeController.java
new file mode 100644
index 00000000..1db49779
--- /dev/null
+++ b/src/main/java/study/controller/JokeController.java
@@ -0,0 +1,76 @@
+package study.controller;
+
+import java.util.Map;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.chat.client.ChatClient;
+import org.springframework.ai.chat.messages.UserMessage;
+import org.springframework.ai.chat.model.ChatResponse;
+import org.springframework.ai.chat.prompt.Prompt;
+import org.springframework.ai.chat.prompt.PromptTemplate;
+import org.springframework.ai.chat.prompt.SystemPromptTemplate;
+import org.springframework.ai.converter.BeanOutputConverter;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import study.common.Functions;
+import study.dto.ActorFilms;
+
+@RestController
+@Slf4j
+public class JokeController {
+    private final ChatClient client;
+
+    public JokeController(ChatClient.Builder builder) {
+        this.client = builder.build();
+    }
+
+    @GetMapping("/joke")
+    public ChatResponse joke(@RequestParam(defaultValue = "Mi-mi") String name, @RequestParam(defaultValue = "pirate") String voice) {
+        var user = new UserMessage("""
+                Tell me about three famous pirates from the Golden Age of Piracy and what they did.
+                Write at least one sentence for each pirate.
+                """);
+        var template = new SystemPromptTemplate("""
+                You are a helpful AI assistant.
+                You are an AI assistant that helps people find information.
+                Your name is {name}.
+                You should reply to the user's request using your name and in the style of a {voice}.
+                """);
+        var system = template.createMessage(Map.of("name", name, "voice", voice));
+        var prompt = new Prompt(user, system);
+        return client.prompt(prompt).call().chatResponse();
+    }
+
+    @GetMapping("/joke2")
+    public ChatResponse joke2(@RequestParam(defaultValue = "Tell me a joke about {topic}") String message, @RequestParam(defaultValue = "Programming") String topic) {
+        //사용자의 입력으로 AI를 호출하면, AI prompt injection 공격에 취약하고, 과금도 많이 될 수 있으므로 주의
+        PromptTemplate template = new PromptTemplate(message);
+        String prompt = template.render(Map.of("topic", topic));
+        return client.prompt(prompt).call().chatResponse();
+    }
+
+    @GetMapping("/actors")
+    public ActorFilms actors(@RequestParam(defaultValue = "Brad Pitt") String actor) {
+        var beanOutputConverter = new BeanOutputConverter<>(ActorFilms.class);
+        var format = beanOutputConverter.getFormat();
+        log.info(format);
+        var userMessage = """
+            Generate the filmography of 5 movies for {actor}.
+            {format}
+            """;
+        var promptTemplate = new PromptTemplate(userMessage);
+        var prompt = promptTemplate.create(Map.of("actor", actor, "format", format));
+        var text = client.prompt(prompt).call().content();
+        log.info(text);
+
+        return beanOutputConverter.convert(text);
+    }
+
+    @GetMapping("/addDays")
+    public String addDays(@RequestParam(defaultValue = "0") int days) {
+        var template = new PromptTemplate("오늘 기준으로 {days}일 뒤 날짜를 알려 줘.");
+        var prompt = template.render(Map.of("days", days));
+        return client.prompt(prompt).tools(new Functions()).call().content();
+    }
+
+}
diff --git a/src/main/java/study/dto/ActorFilms.java b/src/main/java/study/dto/ActorFilms.java
new file mode 100644
index 00000000..4b4dac6b
--- /dev/null
+++ b/src/main/java/study/dto/ActorFilms.java
@@ -0,0 +1,10 @@
+package study.dto;
+
+import lombok.Data;
+
+@Data
+public class ActorFilms {
+    String actor;
+    String[] movies;
+
+}
diff --git a/src/main/java/study/dto/AddDayRequest.java b/src/main/java/study/dto/AddDayRequest.java
new file mode 100644
index 00000000..5b15d39c
--- /dev/null
+++ b/src/main/java/study/dto/AddDayRequest.java
@@ -0,0 +1,5 @@
+package study.dto;
+
+public record AddDayRequest(int days) {
+
+}
diff --git a/src/main/java/study/dto/DateResponse.java b/src/main/java/study/dto/DateResponse.java
new file mode 100644
index 00000000..8bddf0f3
--- /dev/null
+++ b/src/main/java/study/dto/DateResponse.java
@@ -0,0 +1,5 @@
+package study.dto;
+
+public record DateResponse(String date) {
+
+}
diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties
new file mode 100644
index 00000000..ea5e933b
--- /dev/null
+++ b/src/main/resources/application.properties
@@ -0,0 +1,2 @@
+spring.ai.google.genai.api-key=
+spring.ai.google.genai.chat.options.model=gemini-2.5-flash-lite
diff --git a/src/test/java/com/llm_precourse/weather/controller/WeatherControllerTest.java b/src/test/java/com/llm_precourse/weather/controller/WeatherControllerTest.java
new file mode 100644
index 00000000..d37793a9
--- /dev/null
+++ b/src/test/java/com/llm_precourse/weather/controller/WeatherControllerTest.java
@@ -0,0 +1,101 @@
+package com.llm_precourse.weather.controller;
+
+import com.llm_precourse.weather.dto.WeatherResponse;
+import com.llm_precourse.weather.exception.ExternalApiException;
+import com.llm_precourse.weather.exception.InvalidRequestException;
+import com.llm_precourse.weather.exception.UnsupportedCityException;
+import com.llm_precourse.weather.service.WeatherService;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.test.web.servlet.MockMvc;
+
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@WebMvcTest(controllers = WeatherController.class)
+class WeatherControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private WeatherService weatherService;
+
+    @Test
+    @DisplayName("정상적인 city 파라미터로 요청 시 200 OK와 WeatherResponse를 반환한다")
+    void getWeather_success() throws Exception {
+        // given
+        WeatherResponse response = WeatherResponse.builder()
+                .city("Seoul")
+                .temperature(3.4)
+                .feelsLike(1.2)
+                .condition("부분적으로 흐림")
+                .humidity(65.0)
+                .summary("현재 서울의 기온은 3.4℃이고, 체감 온도는 1.2℃입니다. 하늘 상태는 부분적으로 흐림이며, 습도는 65%입니다.")
+                .build();
+
+        Mockito.when(weatherService.getWeather("Seoul"))
+                .thenReturn(response);
+
+        // when & then
+        mockMvc.perform(get("/api/weather")
+                        .param("city", "Seoul"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.city").value("Seoul"))
+                .andExpect(jsonPath("$.temperature").value(3.4))
+                .andExpect(jsonPath("$.feelsLike").value(1.2))
+                .andExpect(jsonPath("$.condition").value("부분적으로 흐림"))
+                .andExpect(jsonPath("$.humidity").value(65.0))
+                .andExpect(jsonPath("$.summary").exists());
+    }
+
+    @Test
+    @DisplayName("WeatherService에서 InvalidRequestException이 발생하면 400과 INVALID_REQUEST 코드를 반환한다")
+    void getWeather_invalidRequest() throws Exception {
+        // given
+        Mockito.when(weatherService.getWeather(anyString()))
+                .thenThrow(new InvalidRequestException("city 파라미터는 필수입니다."));
+
+        // when & then
+        mockMvc.perform(get("/api/weather")
+                        .param("city", "")) // 빈 문자열로 호출
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.code").value("INVALID_REQUEST"))
+                .andExpect(jsonPath("$.message").value("city 파라미터는 필수입니다."));
+    }
+
+    @Test
+    @DisplayName("지원하지 않는 도시일 경우 400과 CITY_NOT_SUPPORTED 코드를 반환한다")
+    void getWeather_unsupportedCity() throws Exception {
+        // given
+        Mockito.when(weatherService.getWeather("Busan"))
+                .thenThrow(new UnsupportedCityException("지원하지 않는 도시입니다."));
+
+        // when & then
+        mockMvc.perform(get("/api/weather")
+                        .param("city", "Busan"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.code").value("CITY_NOT_SUPPORTED"))
+                .andExpect(jsonPath("$.message").value("지원하지 않는 도시입니다."));
+    }
+
+    @Test
+    @DisplayName("외부 API 에러가 발생하면 502와 EXTERNAL_API_ERROR 코드를 반환한다")
+    void getWeather_externalApiError() throws Exception {
+        // given
+        Mockito.when(weatherService.getWeather("Seoul"))
+                .thenThrow(new ExternalApiException("외부 날씨 API 호출 중 오류가 발생했습니다."));
+
+        // when & then
+        mockMvc.perform(get("/api/weather")
+                        .param("city", "Seoul"))
+                .andExpect(status().isBadGateway())
+                .andExpect(jsonPath("$.code").value("EXTERNAL_API_ERROR"))
+                .andExpect(jsonPath("$.message").value("외부 날씨 API 호출 중 오류가 발생했습니다."));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/llm_precourse/weather/domain/CityTest.java b/src/test/java/com/llm_precourse/weather/domain/CityTest.java
new file mode 100644
index 00000000..53387cef
--- /dev/null
+++ b/src/test/java/com/llm_precourse/weather/domain/CityTest.java
@@ -0,0 +1,58 @@
+package com.llm_precourse.weather.domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class CityTest {
+
+    @Test
+    @DisplayName("도시 이름으로 SupportedCity를 정상적으로 찾는다")
+    void from_validCityName() {
+        // given
+        String city = "Seoul";
+
+        // when
+        City result = City.from(city);
+
+        // then
+        assertThat(result).isEqualTo(City.SEOUL);
+        assertThat(result.getLatitude()).isEqualTo(37.5665);
+        assertThat(result.getLongitude()).isEqualTo(126.9780);
+    }
+
+    @Test
+    @DisplayName("대소문자를 구분하지 않고 도시를 찾을 수 있다")
+    void from_ignoreCase() {
+        // given
+        String city = "seOul";
+
+        // when
+        City result = City.from(city);
+
+        // then
+        assertThat(result).isEqualTo(City.SEOUL);
+    }
+
+    @Test
+    @DisplayName("지원하지 않는 도시는 null을 반환한다")
+    void from_unsupportedCity() {
+        // given
+        String city = "Busan";
+
+        // when
+        City result = City.from(city);
+
+        // then
+        assertThat(result).isNull();
+    }
+
+    @Test
+    @DisplayName("null 또는 공백 문자열은 null을 반환한다")
+    void from_nullOrBlank() {
+        assertThat(City.from(null)).isNull();
+        assertThat(City.from("")).isNull();
+        assertThat(City.from("   ")).isNull();
+    }
+}
diff --git a/src/test/java/com/llm_precourse/weather/service/WeatherServiceTest.java b/src/test/java/com/llm_precourse/weather/service/WeatherServiceTest.java
new file mode 100644
index 00000000..0acfbb0b
--- /dev/null
+++ b/src/test/java/com/llm_precourse/weather/service/WeatherServiceTest.java
@@ -0,0 +1,90 @@
+package com.llm_precourse.weather.service;
+
+import com.llm_precourse.weather.common.OpenMeteoClient;
+import com.llm_precourse.weather.domain.City;
+import com.llm_precourse.weather.dto.OpenMeteoResponse;
+import com.llm_precourse.weather.dto.WeatherResponse;
+import com.llm_precourse.weather.exception.InvalidRequestException;
+import com.llm_precourse.weather.exception.UnsupportedCityException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.*;
+
+class WeatherServiceTest {
+
+    /**
+     * 테스트용 가짜 OpenMeteoClient - 실제 HTTP 호출 없이, 우리가 원하는 OpenMeteoResponse만 돌려준다.
+     */
+    private static class FakeOpenMeteoClient extends OpenMeteoClient {
+
+        public FakeOpenMeteoClient() {
+            super(null); // 부모 생성자에 WebClient가 필요하지만, 테스트에서는 사용하지 않으므로 null 전달
+        }
+
+        @Override
+        public OpenMeteoResponse getCurrentWeather(double latitude, double longitude) {
+            // latitude/longitude 가 SEOUL 과 일치한다고 가정
+            OpenMeteoResponse.Current current = new OpenMeteoResponse.Current(
+                    3.4,   // temperature
+                    1.2,   // apparentTemperature
+                    65.0,  // humidity
+                    3      // weatherCode (부분적으로 흐림)
+            );
+            return new OpenMeteoResponse(latitude, longitude, current);
+        }
+    }
+
+    /*@Test
+    @DisplayName("정상적인 도시 이름에 대해 날씨 정보와 요약 문장을 생성한다")
+    void getWeather_success() {
+        // given
+        FakeOpenMeteoClient fakeClient = new FakeOpenMeteoClient();
+        WeatherService weatherService = new WeatherService(fakeClient);
+
+        // when
+        WeatherResponse response = weatherService.getWeather("Seoul");
+
+        // then
+        assertThat(response.getCity()).isEqualTo(City.SEOUL.getCityName());
+        assertThat(response.getTemperature()).isEqualTo(3.4);
+        assertThat(response.getFeelsLike()).isEqualTo(1.2);
+        assertThat(response.getHumidity()).isEqualTo(65.0);
+        assertThat(response.getCondition()).isNotBlank();
+
+        // 요약 문장 검증 (대략적인 형태)
+        assertThat(response.getSummary())
+                .contains("현재")
+                .contains("서울")
+                .contains("기온은 3.4")
+                .contains("체감 온도는 1.2")
+                .contains("습도는 65");
+    }
+
+    @Test
+    @DisplayName("city 파라미터가 비어 있으면 InvalidRequestException 이 발생한다")
+    void getWeather_invalidCityParam() {
+        FakeOpenMeteoClient fakeClient = new FakeOpenMeteoClient();
+        WeatherService weatherService = new WeatherService(fakeClient);
+
+        assertThatThrownBy(() -> weatherService.getWeather(null))
+                .isInstanceOf(InvalidRequestException.class);
+
+        assertThatThrownBy(() -> weatherService.getWeather(""))
+                .isInstanceOf(InvalidRequestException.class);
+
+        assertThatThrownBy(() -> weatherService.getWeather("   "))
+                .isInstanceOf(InvalidRequestException.class);
+    }
+
+    @Test
+    @DisplayName("지원하지 않는 도시 이름이면 UnsupportedCityException 이 발생한다")
+    void getWeather_unsupportedCity() {
+        FakeOpenMeteoClient fakeClient = new FakeOpenMeteoClient();
+        WeatherService weatherService = new WeatherService(fakeClient);
+
+        assertThatThrownBy(() -> weatherService.getWeather("Busan"))
+                .isInstanceOf(UnsupportedCityException.class);
+    }*/
+}
+