AI 엔지니어링은 현재 기술 분야에서 가장 가치 있는 스킬셋 중 하나가 되었습니다
문제는 대부분의 초보자들이 실제로 무엇을 공부해야 할지 명확히 모른다는 점입니다
어떤 사람들은 머신러닝 이론부터 시작합니다
어떤 사람들은 끝없이 튜토리얼을 보면서 시간을 보냅니다
또 다른 사람들은 API, 백엔드 기본기, 또는 실제 제품이 어떻게 만들어지는지 이해하지 못한 채 바로 프롬프트와 에이전트로 뛰어듭니다
결과는 대개 비슷합니다: 많은 혼란과 매우 적은 실전 기술
여러분의 목표가 AI 엔지니어가 되는 것이라면, 인공지능의 모든 분야를 마스터할 필요는 없습니다
실제 세상에서 유용한 AI 시스템을 구축하는 방법을 배우면 됩니다
즉, 다음을 배워야 합니다:
- LLM을 활용한 종단 간 애플리케이션 구축
- OpenAI 및 Anthropic 같은 모델 API 사용
- 프롬프트와 컨텍스트의 적절한 설계
- 구조화된 출력 및 도구 호출 사용
- 필요에 따른 검색 기능 추가
- 사람들이 실제로 사용할 수 있도록 프로젝트 배포
이 가이드는 실용적인 6개월 로드맵을 제공하기 위해 만들어졌습니다
이 글은 10,000자 이상이므로, 읽는 데 몇 시간 또는 그 이상이 걸릴 수 있습니다
하지만 진정한 가치는 여러분이 배워야 할 모든 기술에 대해 리소스와 무엇을 해야 하는지에 대한 명확한 설명이 포함되어 있다는 점입니다
그렇게 하면 6개월 안에 AI 엔지니어링 수준에 도달할 수 있고, 처음 1~2개월 안에 이미 스스로 활용하기 시작할 수 있습니다
이 글을 작성하는 데 40시간 이상이 걸렸으며, 제 친구 @andy_ai0와 함께 작업했습니다
그는 X에서 개인 브랜드를 구축하기 시작했지만, AI를 매우 잘 이해하고 있으며 이 글에 많은 도움을 주었습니다
그가 성장하는 과정에서 여러분의 팔로우와 응원을 받을 자격이 충분히 있다고 생각합니다
이제 글을 시작해 보겠습니다 ⬇️
AI 엔지니어가 실제로 하는 일
많은 사람들이 "AI 엔지니어"라는 말을 들으면 거대한 모델을 처음부터 훈련시키는 사람을 상상합니다
현실에서 대부분의 현대 AI 엔지니어는 훨씬 더 실용적인 일을 합니다
기존 모델 위에 제품과 시스템을 구축합니다
여기에는 일반적으로 다음이 포함됩니다:
- LLM API 연결
- 프롬프트 및 컨텍스트 흐름 설계
- 채팅, 검색 또는 자동화 시스템 구축
- 도구, 데이터베이스 및 외부 API 통합
- 구조화된 출력 처리
- 안정성, 비용 및 지연 시간 개선
- 실제 애플리케이션에 AI 기능 배포
따라서 실제로 AI 엔지니어는 종종 다음과 같은 분야 사이에 위치합니다:
- 소프트웨어 엔지니어링
- 제품 엔지니어링
- 자동화
- 응용 AI
이것이 이 역할이 빠르게 성장하는 이유입니다
기업에는 연구원만 필요한 것이 아닙니다
모델을 가져와 유용한 제품으로 바꿀 수 있는 사람이 필요합니다
그렇기 때문에 이 로드맵은 무거운 이론보다는 실용적인 실행에 더 초점을 맞추고 있습니다
실제 LLM 앱, 검색 시스템, 자동화, 프로덕션 준비 워크플로우를 구축할 수 있다면, 여러분은 이미 대부분의 초보자보다 고용 가능성에 훨씬 가까워진 것입니다
⏩------------------------------------------------------------------------⏪
1개월차: 코딩과 기본기를 확실히 다지기
이번 달의 목표: 기능적인 Python 개발자가 되기
전문가가 될 필요는 없습니다. 기본적인 문법을 검색하지 않고도 간단한 프로그램을 자신 있게 구축할 수 있으면 됩니다
AI 엔지니어링은 무엇보다 소프트웨어 엔지니어링입니다
이후 몇 달 동안의 모든 과정은 깔끔한 Python 코드를 작성하고, 터미널을 사용하고, API를 호출하고, 코드베이스를 관리할 수 있다는 가정 하에 진행됩니다. 이번 달은 그 기초를 다지는 시간입니다
배울 내용
1. Python
Python은 AI 엔지니어링의 언어입니다. 이견이 없습니다. 앞으로 6개월 동안 여러분이 접하게 될 거의 모든 라이브러리, API, 튜토리얼은 Python으로 되어 있습니다
학습 방법:
비디오만 보는 것이 아니라 코드를 직접 작성하도록 강제하는 구조화된 과정으로 시작하세요
초보자가 가장 흔히 저지르는 실수는 콘텐츠를 수동적으로 소비하고, 따라 읽기만 하며, 고개를 끄덕이고, 코드 편집기를 열어보지 않는 것입니다
모든 예제를 직접 코딩하면서 이에 맞서 싸우세요
리소스:
1. Python for Everybody (Coursera, 무료 청강 가능)
링크: https://www.coursera.org/specializations/python
완전 초보자를 위한 최고의 시작점입니다. Dr. Chuck은 인터넷에서 가장 초보자 친화적인 Python 강사 중 한 명입니다
2. freeCodeCamp Python 강좌 (YouTube, 무료)
링크: https://www.youtube.com/watch?v=rfscVS0vtbw
모든 기본기를 다루는 포괄적인 4시간 분량의 비디오입니다
3. CS50P: Introduction to Programming with Python (하버드, 무료)
링크: https://cs50.harvard.edu/python/
더 엄격합니다. 문제 세트와 최종 프로젝트가 포함됩니다. 구조화된 학습을 원한다면 좋은 선택입니다
4. 공식 Python 문서 (튜토리얼)
링크: https://docs.python.org/3/tutorial/
건조하지만 권위적이며, 참고 자료로 사용하세요
중점을 둘 부분:
- 변수, 데이터 타입, 반복문, 조건문, 함수
- 리스트, 딕셔너리, 세트, 튜플
- 파일 I/O 및 JSON 작업
- 클래스와 기본 OOP (읽는 내용을 이해할 수 있을 정도로만)
- try/except를 사용한 오류 처리
- 가상 환경 (venv) 및 pip
- 패키지 관리 – requirements.txt 이해
실습 프로젝트: Python으로 간단한 CLI 도구를 만드세요. JSON 파일을 읽고 쓰는 개인 지출 추적기나, 공개 API(예: 날씨 API)를 호출하여 형식화된 결과를 출력하는 스크립트 같은 것입니다
2. Git과 GitHub
Git은 전문 개발자가 코드를 저장하고 공유하는 방법입니다. 프로젝트 버전 관리, 협업, GitHub에서 포트폴리오 작업을 선보이는 데 지속적으로 필요합니다
학습 방법:
Git은 처음에는 혼란스럽습니다. 멘탈 모델이 명확하지 않기 때문입니다
명령어를 암기하려고 하지 말고, Git이 해결하는 문제가 무엇인지 이해하세요
(변경 사항 추적, 협업 가능, 실수 취소) 그러면 명령어가 이해될 것입니다
리소스:
1. GitHub Skills (무료, 대화형)
링크: https://skills.github.com/
GitHub 자체 내에서 제공되는 공식 대화형 과정입니다. 여기서 시작하세요
2. Learn Git Branching (무료, 대화형)
링크: https://learngitbranching.js.org/
브랜치와 병합을 이해하기 위한 최고의 시각적 도구입니다
3. Pro Git Book (무료 온라인 서적)
링크: https://git-scm.com/book/en/v2
포괄적인 참고 자료입니다. 필요한 장으로 건너뛰어서 보세요
중점을 둘 부분:
- git init, add, commit, push, pull
- 브랜칭과 병합
- .gitignore 이해
- GitHub에서 리포지토리 생성 및 로컬 프로젝트 푸시
- 기본 README 파일 읽기 및 쓰기
실습: 지금부터 여러분이 구축하는 모든 프로젝트는, 작은 스크립트라도, GitHub 리포지토리에 있어야 합니다. 이렇게 하면 습관이 생기고 포트폴리오가 만들어집니다
3. CLI / 터미널 기본기
AI 엔지니어로서 여러분은 전적으로 명령줄에서 스크립트를 실행하고, 패키지를 설치하고, 서버를 관리하고, 파일을 탐색하게 됩니다
터미널에서 느리거나 두려워하는 것은 진정한 병목 현상입니다
리소스:
1. 가장 인기 있는 Linux 및 터미널 명령어 50개 (초보자용 전체 강좌)
링크: https://www.youtube.com/watch?v=ZtqBQ68cfJc
Linux/Mac 초보자에게 좋습니다
2. The Missing Semester of Your CS Education (MIT, 무료)
링크: https://missing.csail.mit.edu/
대부분의 CS 과정에서 건너뛰는 셸 스크립팅, 터미널 도구 및 명령줄 활용 능력을 다룹니다
중점을 둘 부분:
- 탐색: cd, ls, pwd, mkdir, rm
- 파일 읽기: cat, less, grep
- 터미널에서 Python 스크립트 실행
- 환경 변수
- PATH에 대한 기본 이해
4. JSON, API, HTTP 및 비동기 기본기
2개월차 첫날부터 LLM API를 호출하게 될 것입니다
즉, OpenAI나 Anthropic의 SDK를 사용하기 전에 웹 API가 어떻게 작동하는지 이해해야 합니다
리소스:
1. HTTP 기본 – MDN Web Docs (무료)
링크: https://developer.mozilla.org/en-US/docs/Web/HTTP/Overview
HTTP 요청과 응답이 어떻게 작동하는지에 대한 가장 명확한 설명입니다
2. REST API 튜토리얼
간결하고 실용적입니다
3. Python requests 라이브러리 문서
링크: https://requests.readthedocs.io/en/latest/
Python에서 모든 웹 API를 호출하는 방법을 배웁니다
4. Python async/await (무료)
링크: https://realpython.com/async-io-python/
비동기 이해는 나중에 스트리밍 LLM 응답을 작업하는 데 필수적입니다
중점을 둘 부분:
- GET, POST 요청 – 그것이 무엇이고 Python에서 만드는 방법
- JSON 읽기 및 쓰기
- HTTP 상태 코드 (200, 400, 401, 404, 500 – 각각의 의미)
- API 키란 무엇이며 기본 인증 패턴
- async def와 await가 무엇이고 왜 존재하는지
실습 프로젝트: 무료 공개 API(날씨 데이터를 위해 Open-Meteo 사용 – API 키 불필요)를 호출하고 결과를 깔끔한 JSON 출력으로 형식화하는 Python 스크립트를 작성하세요
5. 기본 SQL 및 Pandas
데이터 과학자가 될 필요는 없지만, 정기적으로 데이터를 검사하고, 쿼리하고, 조작해야 합니다
SQL 기본기와 Pandas 활용 능력은 여러분을 지속적으로 구해줄 것입니다
리소스:
1. SQLBolt (무료, 대화형)
처음부터 SQL을 배우는 가장 빠른 방법입니다. 브라우저 내 연습 문제가 포함된 20개의 짧은 레슨입니다
2. Pandas 공식 시작 가이드
링크: https://pandas.pydata.org/docs/getting_started/index.html
10 Minutes to Pandas 튜토리얼을 진행하세요
3. Kaggle Pandas 강좌 (무료)
링크: https://www.kaggle.com/learn/pandas
실습 위주, 실용적, 짧습니다
중점을 둘 부분:
- SQL: SELECT, WHERE, GROUP BY, JOIN, ORDER BY
- Pandas: CSV 로딩, 행 필터링, 열 선택, 기본 집계
6. FastAPI
리소스:
1. FastAPI 공식 튜토리얼 (무료)
링크: https://fastapi.tiangolo.com/tutorial/
정말로 가장 잘 쓰여진 프레임워크 문서 중 하나입니다
처음부터 끝까지 진행하세요. 경로 매개변수, 요청 본문, Pydantic 유효성 검사, 개발 서버 실행을 다룹니다
2. Python API Development (19시간 과정, freeCodeCamp, YouTube, 무료)
링크: https://www.youtube.com/watch?v=ZtqBQ68cfJc
경로, 직렬화, 스키마 유효성 검사, SQL 데이터베이스 통합을 포함한 API 설계 기본기를 다룹니다. 처음부터 전체 소셜 미디어 스타일 API를 구축합니다
중점을 둘 부분: GET 및 POST 엔드포인트 생성, 경로 및 쿼리 매개변수, Pydantic을 사용한 요청 본문, uvicorn 실행, 클라이언트를 작성하지 않고 API를 테스트하기 위해 FastAPI에 내장된 /docs 인터페이스 사용
1개월차 마일스톤
이번 달이 끝날 때까지 다음을 할 수 있어야 합니다:
- 파일을 읽고 쓰고, API를 호출하고, 오류를 처리하는 Python 프로그램 작성
- Git으로 코드 버전을 관리하고 GitHub에 프로젝트 푸시
- 망설임 없이 터미널 탐색
- HTTP 요청이 무엇인지 이해하고 Python으로 요청 생성
- 기본 SQL로 SQLite 데이터베이스 쿼리
- 로컬에서 간단한 FastAPI 앱을 빌드하고 실행
⏩------------------------------------------------------------------------⏪
2개월차: LLM 앱 개발 마스터하기
이번 달의 목표: OpenAI 및 Anthropic API를 사용하여 실제 AI 기반 애플리케이션 구축
끝날 때까지는 안정적으로 작동하는 프롬프트 작성, 모델에서 구조화된 데이터 추출, 함수 호출, 발생할 수 있는 모든 문제 처리에 능숙해져야 합니다
이것이 AI 엔지니어링의 핵심입니다. 로드맵의 다른 모든 내용은 여기서 배우는 것을 기반으로 합니다
배울 내용
1. 프롬프팅 기본기
프롬프팅은 단순히 질문을 공손하게 하는 것이 아닙니다. 근본적으로 확률적인 모델에서 일관되고 신뢰할 수 있는 출력을 생성하는 지침을 작성하는 기술입니다
AI 엔지니어로서 여러분은 여기에서 상당한 시간을 보내게 될 것입니다
학습 방법:
가장 실습 위주이므로 Anthropic의 대화형 튜토리얼로 시작하세요
그런 다음 OpenAI의 공식 가이드를 읽으세요. 그 후에 Prompt Engineering Guide가 모든 것을 통합합니다
세 가지를 모두 순서대로 진행하세요 – 각각이 서로를 강화합니다
리소스:
1. Anthropic의 대화형 프롬프트 엔지니어링 튜토리얼 (무료, GitHub)
링크: https://github.com/anthropics/prompt-eng-interactive-tutorial
9개 장으로 나뉘어진 단계별 과정으로, 연습 문제가 포함되어 있으며 스스로 프롬프트를 작성하고 문제를 해결하는 연습을 많이 할 수 있도록 설계되었습니다
Claude API와 함께 Jupyter 노트북으로 실행하세요
2. Anthropic 프롬프트 엔지니어링 문서 (무료)
링크: https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview
공식 참고 자료입니다. 기본 명확성부터 XML 구조화 및 에이전트 시스템까지 모든 것을 다룹니다
3. OpenAI 프롬프트 엔지니어링 가이드 (무료)
링크: https://platform.openai.com/docs/guides/prompt-engineering
OpenAI의 공식 가이드로, 해당 모델과 잘 작동하고 더 유용한 출력으로 이어지는 프롬프트 형식을 다룹니다
4. PromptingGuide.ai (무료)
링크: https://www.promptingguide.ai/
기본 프롬프팅부터 고급 전략, 함수 호출, 도구 통합 및 에이전트 시스템까지 필수 기술을 다룹니다
중점을 둘 부분: 시스템 메시지와 사용자 메시지의 차이, 특수성이 중요한 이유, 사고 사슬 프롬프팅(단계별로 생각하기), 프롬프트에서 예제 사용(퓨샷), 그리고 작은 표현 변경이 출력 품질을 어떻게 극적으로 바꿀 수 있는지
실습: 실제 작업(문서 요약, 텍스트에서 주요 정보 추출, 피드백 분류)을 선택하고 이에 대한 5가지 다른 프롬프트를 작성하세요. 출력을 비교해 보세요. 프롬프트 설계가 신뢰성에 얼마나 큰 영향을 미치는지 즉시 알게 될 것입니다
3. 구조화된 출력 / JSON 스키마
실제 애플리케이션에서는 LLM의 원시 텍스트를 거의 원하지 않습니다. 코드에서 구문 분석, 저장 및 사용할 수 있는 구조화된 데이터를 원합니다
구조화된 출력은 모델이 사용자가 정의한 스키마와 일치하도록 강제하여 이 문제를 해결합니다
리소스:
1. OpenAI 구조화된 출력 가이드 (공식 문서, 무료)
링크: https://platform.openai.com/docs/guides/structured-outputs
모델이 항상 JSON 스키마를 준수하는 응답을 생성하도록 보장하여 누락된 키나 환각 값에 대해 걱정할 필요가 없게 해주는 기능을 다룹니다
2. Instructor 라이브러리 (무료, 오픈 소스)
링크: https://python.useinstructor.com/
Pydantic 모델을 사용하여 모든 LLM 공급자로부터 구조화된 출력을 얻는 가장 깔끔한 방법입니다
동일한 코드 인터페이스를 사용하여 OpenAI, Anthropic, Google 및 15개 이상의 다른 공급자와 작동하며, 유효성 검사 실패 시 자동 재시도가 포함됩니다
이것이 실제 프로덕션 AI 엔지니어들이 실제로 사용하는 것입니다
3. OpenAI Cookbook: 구조화된 출력 소개 (무료)
링크: https://developers.openai.com/cookbook/examples/structured_outputs_intro/
사고 사슬 출력, 구조화된 데이터 추출 및 UI 생성을 다루는 실용적인 예제로, 실제 사용 사례를 이해하는 데 좋습니다
중점을 둘 부분: 데이터에 대한 Pydantic 모델 정의, API에 스키마 전달, 구조화된 출력과 JSON 모드의 차이 이해, 거부를 우아하게 처리
실습 프로젝트: 송장 또는 영수증 파서를 만드세요. 원시 텍스트(예: "송장 #123, 위젯 3개에 $45.99, 3월 30일까지 납기")를 입력하고 invoice_number, amount, items, due_date와 같은 필드가 있는 구조화된 Python 객체를 반환하도록 하세요
4. 함수 / 도구 호출
도구 호출은 LLM을 텍스트 생성기에서 웹 검색, 데이터베이스 쿼리, API 호출, 코드 실행과 같은 작업을 수행할 수 있는 무언가로 변환합니다. 이 전체 가이드에서 가장 중요한 기술 중 하나입니다
이해 방법: 모델은 실제로 함수를 실행하지 않습니다
프롬프트를 검토하고 도구를 사용해야 한다고 결정할 때 함수 이름과 인수가 포함된 구조화된 호출을 반환합니다
그러면 여러분의 코드가 호출을 실행하고 결과를 다시 보냅니다
리소스:
1. OpenAI 함수 호출 가이드 (공식 문서, 무료)
링크: https://platform.openai.com/docs/guides/function-calling
최고의 참고 자료입니다. 도구 정의, 5단계 호출 흐름, 병렬 호출 및 모범 사례를 다룹니다
2. Anthropic 도구 사용 문서 (무료)
링크: https://docs.anthropic.com/en/docs/build-with-claude/tool-use
Claude를 위한 Anthropic의 동등한 가이드입니다. 개념은 동일하고, 구문이 약간 다릅니다
3. OpenAI Cookbook: 채팅 모델로 함수를 호출하는 방법 (무료, GitHub)
실제 예제와 함께 전체 도구 호출 루프를 안내하는 완전한 실행 가능한 노트북입니다
중점을 둘 부분: JSON 스키마로 함수를 명확하게 설명, 도구 호출 응답 구문 분석, 함수 실행 및 결과 다시 공급, 도구 호출이 필요하지 않은 경우 처리, tool_choice: "auto" 개념
실습 프로젝트: 세 가지 도구( get_weather(city), calculate(expression), search_notes(query) (하드코딩된 딕셔너리 검색만))가 있는 간단한 어시스턴트를 만드세요. 모두 연결하고 모델이 사용자가 요청한 내용에 따라 어떤 도구를 호출할지 결정하는 것을 지켜보세요
5. 스트리밍 응답
스트리밍은 전체 응답을 기다리는 대신 모델의 출력이 생성되는 대로(단어별로) 표시하는 것을 의미합니다. 앱을 훨씬 빠르고 생동감 있게 만듭니다
리소스:
1. OpenAI 스트리밍 문서 (공식, 무료)
링크: https://platform.openai.com/docs/api-reference/streaming
요청에 stream=True를 추가하고 청크를 반복하는 방법에 대한 참고 자료입니다
2. Anthropic 스트리밍 문서 (공식, 무료)
링크: https://docs.anthropic.com/en/api/messages-streaming
Python 예제가 포함된 Anthropic의 스트리밍 API 참고 자료입니다
3. 스트리밍 LLM API 작동 방식 – Simon Willison (무료)
링크: https://til.simonwillison.net/llms/streaming-llm-apis
OpenAI, Anthropic 및 Google에 대해 Server-Sent Events가 내부적으로 어떻게 작동하는지에 대한 명확한 기술적 분석으로, HTTP 수준에서 실제로 무슨 일이 일어나고 있는지 이해하는 데 유용합니다
중점을 둘 부분: stream=True 설정, 델타 청크 반복, 부분에서 전체 응답 조합, StreamingResponse를 사용하여 FastAPI 엔드포인트에 스트리밍 연결
팁: 사용자 대면 앱의 경우 스트리밍이 거의 항상 올바른 선택입니다. 아무도 10초 동안 로딩 스피너를 쳐다보며 전체 응답이 한 번에 나타나기를 기다리지 않습니다
5. 대화 상태
LLM은 상태 비저장입니다 – 호출 간에 메모리가 없습니다. 대화 기록은 모든 요청과 함께 전체 메시지 목록을 보내서 관리하는 것입니다. 이것을 이해하는 것은 기본입니다
리소스:
1. OpenAI 채팅 완성 가이드, 대화 관리 (공식, 무료)
링크: https://platform.openai.com/docs/guides/conversation-state
messages 배열이 어떻게 작동하고 다중 턴 대화를 관리하는 방법에 대한 표준 설명입니다
2. Anthropic Messages API 문서 (공식, 무료)
링크: https://docs.anthropic.com/en/api/messages
Anthropic의 동등한 문서입니다. 같은 개념입니다. 둘 다 읽어서 어떻게 다른지 보는 것이 좋습니다
중점을 둘 부분: messages 배열 구조, 사용자와 어시스턴트 메시지를 모두 추가해야 하는 이유, 컨텍스트 윈도우 제한 및 초과 시 발생하는 상황, 기본 잘림 전략(가장 오래된 메시지 삭제, 기록 요약)
실습 프로젝트: 터미널에서 간단한 다중 턴 챗봇을 만드세요. 각 턴이 messages 목록에 추가됩니다. 기록을 지우는 /reset 명령을 추가하고, 각 교환 후 현재 토큰 수를 출력하세요
6. 비용, 지연 시간 및 토큰 기본기
비용과 토큰을 이해하지 않고 AI 앱을 출시하면 예상치 못한 청구서와 느린 앱으로 끝나게 됩니다. 지루하지만 중요합니다
리소스:
1. OpenAI 가격 페이지 (공식)
링크: https://openai.com/api/pricing
모델별 입력 및 출력 토큰 비용을 알아두세요. 모델을 선택할 때마다 이 페이지를 북마크하고 확인하세요
2. Anthropic 가격 페이지 (공식)
링크: https://www.anthropic.com/pricing
Claude 모델에 대한 동일한 정보
3. OpenAI 토크나이저 도구 (무료, 대화형)
링크: https://platform.openai.com/tokenizer
텍스트를 붙여넣고 정확히 몇 개의 토큰인지 확인하세요. 배우는 동안 계속 사용하세요
4. Tiktoken (Python 라이브러리, 무료)
링크: https://github.com/openai/tiktoken
요청을 보내기 전에 코드에서 토큰을 계산하기 위한 OpenAI의 토크나이저 라이브러리
중점을 둘 부분: 토큰이 무엇인지(약 4자 / 3/4 단어), 입력 토큰과 출력 토큰의 가격이 어떻게 다른지, 컨텍스트 윈도우 크기가 할 수 있는 일에 어떤 영향을 미치는지, 더 작고 빠른 모델과 더 크고 똑똑한 모델 간의 지연 시간 트레이드오프
또한: 모든 것에 GPT-4/Opus를 사용하지 마세요 – 더 저렴한 모델이 간단한 작업에는 종종 충분합니다
7. 실패 처리
LLM API는 실패합니다. 속도 제한에 도달하고, 응답이 시간 초과되고, 모델이 잘못된 형식의 JSON을 반환합니다. 실패를 우아하게 처리하는 것이 데모와 프로덕션 앱을 구분짓는 요소입니다
리소스:
1. OpenAI 오류 코드 참고 자료 (공식, 무료)
링크: https://platform.openai.com/docs/guides/error-codes
발생할 모든 오류 유형과 대처 방법
2. Anthropic 오류 처리 문서 (공식, 무료)
링크: https://docs.anthropic.com/en/api/errors
Claude에 대한 동일한 정보
3. Tenacity (Python 라이브러리, 무료)
링크: https://tenacity.readthedocs.io/
지수 백오프를 사용한 재시도 로직을 모든 Python 함수에 추가하는 깔끔한 라이브러리입니다. 데코레이터 하나로 재시도가 처리됩니다
중점을 둘 부분: 속도 제한 오류(429) 및 지수 백오프, httpx/requests를 사용한 시간 초과 처리, 사용 전 모델 출력 검증, 폴백 전략(다른 모델로 재시도, 캐시된 응답 반환), LLM이 예상치 못한 출력을 반환했다고 앱이 중단되지 않도록 함
8. 프롬프트 인젝션 인식
프롬프트 인젝션은 LLM 애플리케이션의 #1 보안 위험입니다
신뢰할 수 없는 사용자 입력이 시스템 지침과 결합되어 사용자가 프롬프트를 변경, 재정의 또는 새로운 동작을 주입할 수 있게 되어 시스템이 의도하지 않은 작업을 수행하거나 조작된 출력을 생성할 때 발생합니다
보안 전문가가 될 필요는 없지만, 무엇이든 출시하기 전에 이것이 존재한다는 것을 알아야 합니다
리소스:
1. OWASP Top 10 for LLM Apps – LLM01: 프롬프트 인젝션 (무료)
링크: https://genai.owasp.org/llmrisk/llm01-prompt-injection/
직접 주입(탈옥), 문서나 웹사이트와 같은 외부 콘텐츠를 통한 간접 주입, 그리고 실제 공격 시나리오를 다루는 권위 있는 분류 체계입니다.
2. OWASP 프롬프트 인젝션 방지 치트 시트 (무료)
링크: https://cheatsheetseries.owasp.org/cheatsheets/LLM_Prompt_Injection_Prevention_Cheat_Sheet.html
입력 검증, 권한 제어, 출력 검증 등 실용적인 방어 패턴을 제공합니다.
3. Evidently AI: 프롬프트 인젝션이란 무엇인가 (무료)
링크: https://www.evidentlyai.com/llm-guide/prompt-injection-llm
개발자 관점에서 공격 유형, 위험, 그리고 이를 완화하기 위한 설계 패턴을 명확하게 설명하는 자료입니다.
집중해야 할 내용: 직접 주입과 간접 주입의 차이, 시스템 프롬프트가 진정으로 "안전"하지 않은 이유, 도구 접근에 대한 최소 권한 원칙, 그리고 검증되지 않은 LLM 출력을 신뢰하여 중요한 결정을 자동으로 내려서는 안 되는 이유입니다.
2개월 차 마일스톤
이번 달이 끝날 때까지 다음을 할 수 있어야 합니다:
- 특정 작업에 대해 일관되고 신뢰할 수 있는 출력을 생성하는 프롬프트 작성하기
- Pydantic + Instructor를 사용하여 모든 모델에서 구조화된 JSON 데이터 추출하기
- 모델이 Python 함수를 호출할 수 있도록 도구 호출 연결하기
- FastAPI 엔드포인트를 통해 실시간으로 응답 스트리밍하기
- 다중 턴 대화 기록을 적절하게 관리하기
- 요청을 보내기 전에 예상 토큰 비용 계산하기
- 충돌 없이 API 오류, 시간 초과, 잘못된 출력 처리하기
- 프롬프트 인젝션이 무엇인지 설명하고 기본적인 방어 기법 적용하기
⏩------------------------------------------------------------------------⏪
3개월 차: RAG 제대로 배우기
이번 달의 목표: LLM이 학습 데이터에만 의존하지 않고 사용자 문서를 바탕으로 질문에 답변할 수 있는 시스템을 구축하는 것입니다.
이번 달이 끝날 때까지 문서를 읽어들이고(ingest), 임베딩하여 저장하고, 쿼리 시점에 올바른 청크를 검색(recover)하여 근거가 있고 정확하며 인용 가능한 답변을 생성할 수 있어야 합니다.
RAG는 현재 AI 엔지니어링 분야에서 가장 수요가 많은 실용적인 기술입니다. 고객 지원 봇, 내부 지식 베이스, 문서 Q&A 등 실제 기업의 거의 모든 AI 사용 사례가 RAG를 기반으로 구축됩니다.
단순히 튜토리얼을 따라 하는 것이 아니라 깊이 이해하는 것이 좋은 엔지니어와 위대한 엔지니어를 가르는 기준입니다.
1. 임베딩(Embeddings)
RAG 시스템을 구축하기 전에 임베딩이 실제로 무엇인지 이해해야 합니다. 이는 다른 모든 것이 구축되는 기초이기 때문입니다.
텍스트 임베딩은 텍스트 조각을 고차원 벡터 공간에 투영(project)한 것입니다.
이 공간에서 텍스트의 위치는 긴 숫자 시퀀스로 표현됩니다.
중요한 점은 의미적으로 유사한 텍스트는 해당 공간에서 서로 가깝게 위치하게 된다는 것입니다. 이것이 유사도 검색을 가능하게 만드는 핵심입니다.
자료:
1. Stack Overflow 블로그: 텍스트 임베딩에 대한 직관적인 소개 (무료)
링크: https://stackoverflow.blog/2023/11/09/an-intuitive-introduction-to-text-embeddings/
초보자를 위한 최고의 설명입니다. 수년간 NLP 제품을 구축해 온 개발자가 작성했으며, 수학보다는 올바른 직관을 구축하는 데 중점을 둡니다.
2. Google ML Crash Course: 임베딩 (무료)
링크: https://developers.google.com/machine-learning/crash-course/embeddings
밀집 벡터 표현(dense vector representation)이 원-핫 인코딩으로는 해결할 수 없는 문제, 특히 항목 간의 의미적 관계를 포착하는 방법을 설명합니다.
3. HuggingFace: 임베딩 시작하기 (무료)
링크: https://huggingface.co/blog/getting-started-with-embeddings
실습 가이드입니다. sentence-transformers 라이브러리를 사용하여 임베딩을 생성하고, 이를 호스팅하며, 실제 FAQ 데이터셋을 대상으로 의미 검색(semantic search)에 사용하는 방법을 보여줍니다.
4. OpenAI Embeddings 가이드 (공식 문서, 무료)
링크: https://platform.openai.com/docs/guides/embeddings
코드에서 OpenAI의 text-embedding-3-small 및 text-embedding-3-large 모델을 사용하기 위한 참고 자료입니다.
집중해야 할 내용: 벡터가 개념적으로 무엇인지, 유사한 텍스트가 왜 유사한 벡터를 생성하는지, 코사인 유사도(Cosine similarity)가 어떻게 작동하는지, 임베딩 모델(OpenAI, HuggingFace sentence-transformers) 간의 차이점, 그리고 임베딩 차원(embedding dimension)이 실제로 의미하는 바입니다.
실습: 관련 주제의 문장 20개를 가져와 OpenAI 또는 sentence-transformers를 사용하여 임베딩하고, 쿼리와 가장 유사한 3개를 반환하는 간단한 최근접 이웃 검색(nearest-neighbor search)을 작성해 보세요. 이것은 말 그대로 RAG의 핵심을 축소한 것입니다.
2. 청킹(Chunking)
문서 전체를 임베딩하기에는 너무 큽니다. 청킹은 임베딩 전에 문서를 더 작은 조각으로 나누는 과정입니다.
문서를 어떻게 청킹하느냐에 따라 시스템이 관련 정보를 찾고 정확한 답변을 제공하는 능력이 직접적으로 영향을 받습니다. 완벽한 검색 시스템이라도 부적절하게 준비된 데이터를 대상으로 검색하면 실패합니다.
자료:
1. Weaviate: RAG를 위한 청킹 전략 (무료)
링크: https://weaviate.io/blog/chunking-strategies-for-rag
가장 실용적인 가이드입니다. 고정 크기(fixed-size), 재귀적(recursive), 의미적(semantic) 청킹을 다루며, 각각을 언제 사용해야 하는지에 대한 명확한 지침을 제공합니다.
2. Unstructured: RAG 모범 사례를 위한 청킹 (무료)
링크: https://unstructured.io/blog/chunking-for-rag-best-practices
청크 크기, 중복(overlap), 그리고 임베딩 모델의 컨텍스트 윈도우가 하드 제한을 부과하는 방식에 대한 기술적인 심층 분석입니다.
실험을 위한 좋은 출발점은 약 250 토큰(약 1,000자)의 청크 크기와 경계에서 컨텍스트 손실을 방지하기 위해 연속 청크 간 10-20%의 중복을 결합하는 것입니다.
3. LangChain Text Splitters 문서 (공식, 무료)
링크: https://python.langchain.com/docs/concepts/text_splitters/
코드에서 RecursiveCharacterTextSplitter, MarkdownTextSplitter 및 의미적 분할기를 사용하기 위한 실용적인 참고 자료입니다.
집중해야 할 내용: 기준선으로 중복이 있는 고정 크기 청킹, 구조화된 문서를 위한 재귀적 청킹, 더 나은 경계 감지를 위한 의미적 청킹, 그리고 핵심 트레이드오프(청크가 너무 크면 검색 정밀도가 떨어지고, 너무 작으면 컨텍스트가 손실됨)입니다.
초보자 팁: LangChain의 RecursiveCharacterTextSplitter를 chunk_size=500, chunk_overlap=50으로 설정하여 시작하세요. 이는 대부분의 문서에 가장 합리적인 기본값이며, 개선할 수 있는 작업 기준선을 제공합니다.
3. 벡터 데이터베이스(Vector Databases)
임베딩을 확보한 후에는 이를 효율적으로 저장하고 검색할 공간이 필요합니다. 이것이 바로 벡터 데이터베이스의 용도입니다.
올바른 선택은 상황에 따라 다릅니다: 빠른 로컬 프로토타이핑에는 Chroma, 관리형 턴키 방식의 확장에는 Pinecone, 강력한 하이브리드 검색을 제공하는 오픈 소스 유연성에는 Weaviate, 복잡한 필터와 비용 효율적인 자체 호스팅에는 Qdrant, 그리고 이미 PostgreSQL을 사용 중이라면 시스템을 추가로 도입하지 않기 위해 pgvector를 선택하세요.
자료:
1. Chroma 공식 문서 (무료)
링크: https://docs.trychroma.com/
Chroma는 개발 속도와 단순성을 중시하는 개인 개발자 및 소규모 팀에 완벽하며, 관리할 인프라 없이 인메모리 또는 로컬에서 실행됩니다.
2. Pinecone 학습 센터 (무료)
링크: https://www.pinecone.io/learn/
벡터 검색 개념, 하이브리드 검색 및 RAG 파이프라인을 다루는 훌륭한 무료 튜토리얼입니다. Pinecone을 사용하지 않더라도 공급업체에 종속되지 않는 좋은 자료를 제공합니다.
3. Qdrant 문서 (무료)
링크: https://qdrant.tech/documentation/
고급 필터링이 가능한 프로덕션 환경에 가장 적합한 오픈 소스 옵션입니다. 매우 빠르고 유연하며 자체 호스팅이 무료입니다.
4. pgvector (오픈 소스, 무료)
링크: https://github.com/pgvector/pgvector
이미 PostgreSQL을 사용하는 시스템을 구축 중이라면 pgvector는 새로운 인프라 없이 기존 데이터베이스에 직접 벡터 검색 기능을 추가합니다.
집중해야 할 내용: 컬렉션 생성, 메타데이터와 함께 임베딩 삽입, top_k를 사용한 유사도별 쿼리, 그리고 쿼리 시점에 메타데이터로 필터링하는 방법입니다.
인덱싱 알고리즘(HNSW, IVF)을 이해할 필요는 없습니다. 사용 방법만 알면 됩니다.
실습 프로젝트: 공개 문서(예: Python 문서 또는 Wikipedia 기사 덤프)에서 50-100페이지를 메타데이터(소스 URL, 섹션 제목)와 함께 Chroma에 인덱싱하세요. 모든 질문에 대해 가장 관련성 높은 5개의 청크를 검색하는 쿼리 함수를 작성하세요.
4. 메타데이터 필터링(Metadata Filtering)
실제 애플리케이션에서는 원시 유사도 검색만으로는 충분하지 않습니다. 메타데이터 필터링을 사용하면 날짜, 출처, 문서 유형, 사용자, 카테고리 등 각 청크와 함께 저장된 모든 속성을 기준으로 검색 범위를 관련 하위 집합으로 제한할 수 있습니다.
자료:
1. Pinecone: 메타데이터 필터링 가이드 (무료)
링크: https://docs.pinecone.io/guides/data/filter-with-metadata
유사도 검색 전이나 중에 메타데이터 필드로 벡터를 필터링하는 방법을 코드 예제와 함께 명확하게 설명합니다.
2. LlamaIndex: 메타데이터 필터 가이드 (공식 문서, 무료)
링크: https://docs.llamaindex.ai/en/stable/module_guides/querying/node_postprocessors/node_postprocessors/
LlamaIndex 파이프라인에서 쿼리 시점에 필터를 적용하는 방법을 설명합니다.
집중해야 할 내용: 수집 시점에 모든 청크에 관련 메타데이터(소스 파일 이름, 페이지 번호, 섹션, 날짜, 카테고리)를 태깅하고, 쿼리 시점에 이러한 필드를 사용하여 결과를 필터링하는 것입니다. 이것이 장난감 데모와 사용자가 "2025년 4분기-2026년 1분기 보고서 결과만 보여줘"라고 요청할 수 있는 프로덕션 시스템의 차이를 만듭니다.
5. 재순위화(Reranking)
재순위화는 모든 키워드 또는 벡터 검색 시스템의 검색 품질에 의미론적 향상을 추가하는 기술입니다.
1차 검색이 후보 집합을 반환한 후, 재순위화기는 벡터 근접성만이 아닌 쿼리에 대한 실제 컨텍스트 관련성을 기반으로 해당 결과의 점수를 다시 매깁니다.
2단계 패턴은 다음과 같습니다: 임베딩 및 검색(빠르고, 근사치) → 상위 k개 재순위화(느리지만, 더 정확). 그 결과 약간의 지연 시간 비용만으로 검색 품질이 극적으로 향상됩니다.
자료:
1. Cohere 재순위화 문서 (공식, 무료)
링크: https://docs.cohere.com/docs/reranking-with-cohere
시작하기 가장 좋은 곳입니다. 이메일 및 JSON 문서와 같은 반구조화된 데이터를 포함한 전체 재순위화 워크플로우를 다룹니다. 기존 검색 파이프라인에 단 한 줄의 코드만 추가하면 됩니다.
2. LangChain: Cohere Reranker 통합 (공식 문서, 무료)
링크: https://python.langchain.com/docs/integrations/retrievers/cohere-reranker/
ContextualCompressionRetriever를 사용하여 Cohere 재순위화를 LangChain 검색기에 연결하는 방법을 설명합니다.
집중해야 할 내용: 2단계 검색-후-재순위화 패턴, bi-encoder(1차 임베딩 검색에 사용)와 cross-encoder(재순위화에 사용)의 차이점, 그리고 상위 20개 결과를 재순위화할 때와 상위 5개 결과를 재순위화할 때의 실질적인 지연 시간/품질 트레이드오프입니다.
6. 검색 품질 문제(Retrieval Quality Issues)
대부분의 RAG 실패는 모델 실패가 아니라 검색 실패입니다. 검색이 잘못될 수 있는 방식을 이해하는 것은 실제 시스템을 디버깅하는 데 필수적입니다.
알아야 할 일반적인 문제:
- 의미적 표류(Semantic drift): 정보가 존재함에도 불구하고 쿼리 임베딩이 관련 청크 임베딩과 일치하지 않습니다. 해결책: 쿼리 재작성(query rewriting) 또는 HyDE(Hypothetical Document Embeddings)를 시도해 보세요.
- 청크 경계 문제(Chunk boundary problems): 관련 정보가 두 개의 청크에 걸쳐 분할되어 있습니다. 해결책: 중복을 늘리거나 의미적 청킹을 사용하세요.
- 메타데이터 컨텍스트 부족(Missing metadata context): 청크가 쿼리와 의미적으로 유사하지만 잘못된 문서, 날짜 또는 사용자에 속합니다. 해결책: 메타데이터 필터링을 사용하세요.
- top-k 값이 너무 작음(Top-k too small): 올바른 청크가 존재하지만 검색된 상위 5개 결과 안에 포함되지 않습니다. 해결책: 검색 시 top_k를 늘리고 재순위화 후에 줄이세요.
자료:
1. LangChain: 쿼리 변환(Query Transformations) (무료)
링크: https://python.langchain.com/docs/how_to/#query-analysis
쿼리 재작성, step-back prompting 및 HyDE를 다룹니다.
2. Pinecone: 검색 품질 향상 (무료)
링크: https://www.pinecone.io/learn/retrieval-augmented-generation/#retrieval-quality
일반적인 실패 모드와 해결 방법에 대한 실용적인 안내서입니다.
7. 할루시네이션 감소(Hallucination Reduction)
RAG는 기본 LLM에 비해 할루시네이션을 극적으로 줄여주지만 완전히 제거하지는 못합니다.
런타임에 검색된 사실을 모델에 제공함으로써 RAG는 학습 데이터에만 의존하는 대신 실제 출처에 응답을 고정(anchor)시키며, 모델의 출력은 이러한 출처를 인용하여 투명성과 신뢰도를 높일 수 있습니다.
그러나 검색 실패, 잘못된 청크 및 상충되는 정보로 인해 모델이 사실을 지어낼(hallucinate) 가능성은 여전히 존재합니다.
자료:
1. Zep: LLM 할루시네이션 줄이기 – 개발자 가이드 (무료)
링크: https://www.getzep.com/ai-agents/reducing-llm-hallucinations/
프롬프트 근거 확보 전략(prompt grounding strategies), 사실 기반 작업을 위한 사고의 사슬(chain-of-thought), 출력 검증 패턴을 다루는 실용적인 개발자 중심 가이드입니다.
2. Voiceflow: LLM 할루시네이션을 줄이는 5가지 방법 (무료)
링크: https://www.voiceflow.com/blog/prevent-llm-hallucinations
결합 전략에 대한 훌륭한 개요를 제공합니다: RAG + 사고의 사슬 + 가드레일(guardrails)은 단일 접근 방식보다 함께 사용할 때 훨씬 뛰어난 성능을 보입니다.
집중해야 할 내용: 제공된 컨텍스트에서만 답변하고(답변이 없을 때는 "모르겠습니다"라고 말하도록) 모델을 프롬프팅하고, 응답을 표시하기 전에 신뢰도 임계값(confidence threshold)을 추가하며, LLM을 탓하기 전에 항상 검색 품질을 검증하는 것입니다.
8. 인용 및 근거 확보(Citations and Grounding)
근거가 확보된(grounded) RAG 시스템은 단순히 답변만 제공하는 것이 아니라 답변의 출처를 알려줍니다. 이는 사용자 신뢰와 디버깅에 매우 중요합니다.
자료:
1. Anthropic: Claude에 출처 제공하기 (문서, 무료)
링크: https://docs.anthropic.com/en/docs/build-with-claude/citations
출처 참조와 함께 인용된 응답을 생성하도록 Claude를 프롬프팅하는 방법을 설명합니다.
2. LangChain: 출처가 있는 RAG (무료)
링크: https://python.langchain.com/docs/how_to/qa_sources/
LangChain RAG 파이프라인에서 답변과 함께 출처 문서를 반환하는 방법을 설명합니다.
집중해야 할 내용: 청크 메타데이터(소스 파일 이름, 페이지 번호, URL)를 프롬프트 컨텍스트에 전달하고, 모델이 답변에서 출처를 참조하도록 지시하며, UI 또는 API 응답에서 해당 출처를 표시하는 것입니다.
9. RAG 프레임워크: LangChain 또는 LlamaIndex
RAG 파이프라인을 처음부터 구축할 필요는 없습니다. 이 분야를 지배하는 두 가지 프레임워크를 알아두는 것이 좋습니다.
LlamaIndex는 검색과 인덱싱을 최우선으로 하도록 최적화되어 있습니다. 수집, 청킹, 임베딩 및 쿼리를 몇 줄의 코드로 추상화하여 오후에 작동하는 프로토타입을 구축할 수 있게 해줍니다.
LangChain은 애플리케이션이 오케스트레이션 엔진처럼 보일 때 빛을 발합니다. 다중 에이전트 워크플로우, 도구 호출, 답변을 생성하기 전에 여러 LLM이나 외부 API를 쿼리하는 조건부 체인에 탁월합니다.
3개월 차에는 RAG를 위해 LlamaIndex로 시작하세요. 4개월 차 에이전트 작업을 시작할 때 LangChain으로 전환하세요.
자료:
1. LlamaIndex: RAG 소개 (공식 문서, 무료)
링크: https://developers.llamaindex.ai/python/framework/understanding/rag/
RAG의 5가지 핵심 단계(로딩, 인덱싱, 저장, 쿼리, 평가)와 LlamaIndex가 각 단계를 어떻게 처리하는지 다룹니다.
2. LlamaIndex 스타터 튜토리얼 (공식 문서, 무료)
링크: https://developers.llamaindex.ai/python/framework/getting_started/starter_example/
공식 퀵스타트입니다. 30줄 미만으로 작동하는 RAG 시스템을 구축하세요.
3. LangChain: RAG 에이전트 구축 (공식 문서, 무료)
링크: https://docs.langchain.com/oss/python/langchain/rag
40줄의 최소 버전에서 재순위화가 포함된 전체 검색 파이프라인까지, RAG 에이전트를 사용하여 비정형 텍스트에 대한 Q&A 앱을 구축하는 방법을 보여줍니다.
실습 프로젝트: "내 문서와 대화하는" 앱을 구축하세요. 10-20개의 PDF 또는 텍스트 파일(자체 노트, 교재 챕터, 제품 문서 등 무엇이든)을 수집(ingest)하세요. 질문을 받고, 재순위화를 통해 가장 관련성 높은 상위 5개 청크를 검색하고, Claude 또는 OpenAI에서 인용된 답변을 반환하는 FastAPI 엔드포인트를 구축하세요. 이는 실제 포트폴리오 작품이 될 것입니다.
3개월 차 마일스톤
이번 달이 끝날 때까지 다음을 할 수 있어야 합니다:
- 임베딩이 무엇이고 유사한 텍스트가 왜 유사한 벡터를 생성하는지 설명하기
- 적절한 전략을 사용하여 모든 문서를 지능적으로 청킹하기
- 메타데이터 필터링을 통해 벡터 데이터베이스에 임베딩을 저장하고 쿼리하기
- 검색 품질을 향상시키기 위해 재순위화 단계 추가하기
- 일반적인 검색 실패를 체계적으로 디버깅하기
- LlamaIndex 또는 LangChain을 사용하여 문서를 수집하고 관련 청크를 검색하며 근거가 있고 인용된 답변을 반환하는 완전한 종단 간(end-to-end) RAG 파이프라인 구축하기
⏩------------------------------------------------------------------------⏪
4개월 차: 에이전트, 도구, 워크플로우 및 평가
이번 달의 목표: 일련의 작업을 자율적으로 수행하고, 다단계 워크플로우를 연결하며, 구축한 시스템이 제대로 작동하는지 비판적으로 평가할 수 있는 AI 시스템을 구축하는 것입니다.
이번 달이 끝날 때까지 실제 에이전트를 처음부터 구축하고, 에이전트가 잘못된 선택인 경우를 이해하며, 구축한 모든 것의 성능을 측정할 수 있어야 합니다.
이 단계에서 AI 엔지니어링은 진정으로 복잡해집니다. 4개월 차의 기술은 주니어 AI 엔지니어와 전체 AI 기능을 종단 간 소유할 수 있는 사람을 구분짓습니다.
1. 에이전트 루프(Agent Loops)
에이전트는 마법이 아닙니다. 놀라울 정도로 간단한 패턴입니다.
에이전트를 관찰, 추론, 행동을 지속적으로 순환하는 목표 지향 시스템으로 생각하세요.
이 루프를 통해 에이전트는 단순한 질문과 답변을 넘어 실제 자동화, 도구 사용, 그리고 즉각적인 적응이 필요한 작업을 처리할 수 있습니다.
"생각"은 프롬프트에서 이루어지고, "분기"는 에이전트가 사용 가능한 도구 중에서 선택할 때 발생하며, "실행"은 외부 함수를 호출할 때 이루어집니다. 그 외의 모든 것은 단순한 배관(plumbing)일 뿐입니다.
이것을 내면화하면 가장 복잡한 에이전트 프레임워크라도 읽을 수 있게 됩니다.
자료:
1. Anthropic: 효과적인 에이전트 구축 (공식, 무료)
링크: https://www.anthropic.com/research/building-effective-agents
프로덕션 환경의 에이전트에 관한 최고의 단일 글입니다. 에이전트 코드를 한 줄도 작성하기 전에 이 글을 읽으세요.
2. OpenAI: 에이전트 구축을 위한 실용 가이드 (공식 PDF, 무료)
링크: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf
프로덕션 환경의 에이전트 패턴, 가드레일 및 안전 패턴을 다루는 OpenAI의 보충 가이드입니다.
3. freeCodeCamp: 오픈 소스 LLM 에이전트 핸드북 (무료)
링크: https://www.freecodecamp.org/news/the-open-source-llm-agent-handbook/
에이전트 루프, LangGraph, CrewAI, 계획, 메모리 및 도구 사용을 다루는 포괄적인 실용 가이드입니다. 빠르게 실습을 시작하기 좋습니다.
4. LangChain Academy: LangGraph 소개 (무료 강좌)
링크: https://academy.langchain.com/courses/intro-to-langgraph
가장 널리 사용되는 에이전트 오케스트레이션 프레임워크인 LangGraph의 공식 무료 강좌입니다. 상태, 메모리, 인간-인-더-루프(human-in-the-loop) 등을 다룹니다.
집중해야 할 내용: 인지(perceive) → 계획(plan) → 행동(act) → 관찰(observe) 주기, 에이전트 루프가 종료되는 방식, 루프 내에서 도구 호출이 실패할 때 발생하는 상황, 그리고 에이전트가 분기 결정을 내리는 LLM이 있는 while 루프에 불과하다는 점입니다.
실습: 프레임워크 없이 OpenAI 또는 Anthropic API를 직접 사용하여 처음부터 에이전트를 구축하세요. 3개의 도구, 목표 및 루프를 제공하세요. 이것이 프레임워크가 추상화하는 것을 실제로 이해하기 위해 할 수 있는 가장 가치 있는 일입니다.
2. 도구 선택(Tool Selection)
좋은 도구를 작성하는 것은 작업의 절반입니다. 도구와 해당 매개변수에 대한 설명은 LLM을 위한 사용자 매뉴얼입니다. 매뉴얼이 모호하면 LLM이 도구를 오용할 것입니다. 고통스러울 정도로 철저하게 명시적으로 설명하세요.
설명이 부실한 도구는 잘못 호출되거나, 잘못된 시기에 호출되거나, 완전히 무시될 것입니다. 잘 설명된 도구는 예측 가능하게 동작하며 다양한 입력 범위에서 올바르게 선택됩니다.
자료:
1. OpenAI: 함수 호출 모범 사례 (공식 문서, 무료)
링크: https://platform.openai.com/docs/guides/function-calling/best-practices
명명 규칙 및 매개변수 문서화 패턴과 함께 안정적으로 작동하는 도구 설명을 작성하기 위한 표준 가이드입니다.
2. Anthropic: 도구 사용 모범 사례 (공식 문서, 무료)
Anthropic의 동등한 가이드입니다. 모델이 선택하도록 할 때와 특정 도구를 강제할 때에 대한 지침에 특히 주의하세요.
집중해야 할 내용: 자명한 동사 형태의 도구 이름 작성, 도구를 호출해야 하는 시점을 설명하는 설명 작성(도구가 무엇을 하는지뿐만 아니라), 매개변수를 최소화하고 잘 타입 지정하며, 호출자를 LLM으로 간주하고 도구를 설계하는 것입니다.
초보자 팁: 모든 도구 설명을 "문서가 없고 이 JSON 스키마만 있다면, 이 도구를 언제, 어떻게 호출해야 하는지 정확히 알 수 있을까?"라고 자문하며 테스트하세요. 그렇지 않다면 더 많은 작업이 필요합니다.
3. 상태 관리(State Management)
LangGraph에서 상태(state)는 그래프를 통해 흐르는 공유 메모리 객체입니다. 메시지, 변수, 중간 결과 및 결정 기록 등 모든 관련 정보를 저장하며 실행 전반에 걸쳐 자동으로 관리됩니다.
상태를 이해하는 것은 다중 턴 작업을 처리하고, 실패로부터 복구하며, 구성 요소 간에 깔끔하게 핸드오프할 수 있는 에이전트를 구축하는 열쇠입니다.
자료:
1. LangGraph 공식 문서: 상태 관리 (무료)
링크: https://langchain-ai.github.io/langgraph/concepts/low_level/#state
4. 재시도 및 실패 처리
일반 LLM 호출과 달리 에이전트는 다양한 방식으로 실패합니다. 루프 중간의 잘못된 도구 호출은 상태를 손상시키거나, 무한 루프를 유발하거나, 조용히 잘못된 답변을 생성할 수 있습니다. 이 모든 상황에 대한 명시적인 전략이 필요합니다.
리소스:
1. LangGraph: 오류 처리 및 재시도 (공식 문서, 무료)
링크: https://langchain-ai.github.io/langgraph/how-tos/autofill-tool-errors/
LangGraph의 도구 노드 수준에서 자동 오류 처리 및 재시도 로직을 추가하는 방법을 설명합니다.
2. OpenAI 실용 에이전트 가이드: 가드레일 섹션 (무료)
링크: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf
가드레일을 다계층 방어 체계로 설명합니다. LLM 기반 검사, 정규식과 같은 규칙 기반 필터, 중재 API를 결합하여 에이전트 루프의 모든 단계에서 입력과 출력을 검증합니다.
집중해야 할 내용: 무한 루프 방지를 위한 최대 반복 횟수 제한, 지수 백오프를 사용한 도구별 재시도, 에이전트를 중단시키지 않으면서 도구 실행 계층에서 예외를 포착하고 기록하는 방법, 실패를 사용자에게 표시할지 조용히 재시도할지 결정하는 시점
5. 에이전트를 사용하지 말아야 할 때
이것은 AI 엔지니어링에서 가장 중요하면서도 가장 간과되는 기술 중 하나입니다. 에이전트는 흥미롭지만 느리고, 비용이 많이 들고, 예측 불가능하며, 디버깅이 어렵습니다. 더 간단한 해결책을 사용해야 할 때를 아는 것은 좋은 판단력을 나타냅니다.
Anthropic은 가능한 가장 간단한 해결책을 찾고 필요할 때만 복잡성을 높일 것을 권장합니다. 이는 에이전트 시스템을 전혀 구축하지 않는 것을 의미할 수도 있습니다.
에이전트 시스템은 지연 시간과 비용을 희생하여 더 나은 작업 성능을 얻습니다. 이러한 트레이드오프가 언제 합리적인지 신중히 고려해야 합니다.
의사 결정 프레임워크는 다음과 같습니다:
- 올바른 컨텍스트로 하나의 프롬프트로 해결할 수 있는 작업이라면 단일 LLM 호출을 사용하세요.
- 단계가 고정적이고 예측 가능하다면 워크플로우를 사용하세요.
- 단계 수가 진정으로 예측 불가능하고 동적 의사 결정이 필요한 경우에만 에이전트를 사용하세요.
리소스:
1. Anthropic: 효과적인 에이전트 구축, 에이전트 사용 시기 (공식, 무료)
링크: https://www.anthropic.com/research/building-effective-agents
이 질문에 대한 가장 권위 있는 답변으로, 모델을 만든 팀이 직접 제공합니다.
2. Simon Willison: 에이전틱 루프 설계 (무료)
링크: https://simonwillison.net/2025/Sep/30/designing-agentic-loops/
시니어 엔지니어의 실용적인 관점에서 에이전트 복잡성이 정당화되는 시기와 에이전틱 루프 설계에 대한 사고 방식을 다룹니다.
암기해야 할 내용: 3번의 고정 LLM 호출 체인은 3번의 호출을 할 수 있는 에이전트보다 항상 빠르고, 저렴하며, 디버깅이 더 쉽습니다. 에이전트는 진정으로 개방형 작업을 위해 남겨두세요.
6. 다단계 워크플로우
"단일 프롬프트"와 "전체 에이전트" 사이에는 생산적인 중간 지대인 워크플로우가 있습니다. 워크플로우는 작업을 고정된 하위 작업으로 명확하게 분해할 수 있을 때 이상적입니다. 각 개별 LLM 호출을 더 쉽고 집중된 작업으로 만들어 지연 시간과 높은 정확성을 맞바꿉니다.
일반적인 패턴으로는 프롬프트 체이닝(한 호출의 출력이 다음 호출의 입력이 되는), 라우팅(입력을 분류하여 전문 핸들러로 전송), 병렬화(여러 호출을 동시에 실행하고 집계), 오케스트레이터-서브에이전트(하나의 LLM이 계획을 세우고 다른 LLM이 실행) 등이 있습니다.
리소스:
1. Anthropic: 워크플로우 패턴 (공식, 무료)
링크: https://www.anthropic.com/research/building-effective-agents#workflow-patterns
다이어그램과 코드 예제와 함께 모든 주요 패턴을 다룹니다. 병렬화 및 오케스트레이션 섹션이 특히 유용합니다.
2. LangGraph: 멀티 에이전트 네트워크 (공식 문서, 무료)
링크: https://langchain-ai.github.io/langgraph/concepts/multi_agent/
감독자 및 핸드오프 패턴을 사용하여 여러 에이전트를 네트워크로 연결하는 방법을 설명합니다.
실습 프로젝트: 3단계 콘텐츠 파이프라인 구축:
1단계 – LLM이 기사에서 핵심 사실을 추출합니다.
2단계 – 다른 LLM 호출이 해당 사실을 사용하여 트윗, LinkedIn 게시물, 요약본을 병렬로 생성합니다.
3단계 – 최종 LLM 호출이 세 가지 모두를 품질에 따라 평가하고 최고를 선택합니다.
에이전트가 필요 없으며 순수 워크플로우입니다.
7. 평가 도구 (Eval Harnesses)
평가(Evals)는 AI 시스템이 실제로 작동하는지 확인하는 방법입니다. 직접 테스트한 몇 가지 예시뿐만 아니라 수백 개의 입력에 걸쳐 체계적으로 확인합니다.
AI 에이전트는 강력하지만 확률적이고 다단계적인 동작으로 인해 많은 실패 지점이 발생하기 때문에 배포가 복잡합니다.
에이전트의 다른 부분(LLM, 도구, 검색기, 워크플로우)은 각각 고유한 평가 접근 방식이 필요합니다.
리소스:
1. DeepEval (오픈 소스, 무료)
링크: https://deepeval.com/docs/getting-started
pytest에서 영감을 받은 오픈 소스 LLM 평가 프레임워크입니다. 입력과 예상 출력으로 테스트 케이스를 작성하고, 환각, 답변 관련성, 사실 일관성을 포함한 50개 이상의 내장 메트릭으로 실행하며, 버전 간 회귀를 포착합니다.
링크: https://github.com/promptfoo/promptfoo
자동화된 테스트 스위트로 LLM 앱을 테스트하고 평가하기 위한 CLI 및 라이브러리입니다. 여러 모델에서 여러 프롬프트를 나란히 비교하고, CI/CD 통합 및 보안 취약점에 대한 레드 팀을 지원합니다.
3. LangSmith (무료 티어)
링크: https://smith.langchain.com/
LangChain 및 LangGraph 앱을 위한 추적, 디버깅 및 평가 도구입니다. 무료 티어는 충분히 제공되며, 추적 UI는 에이전트 루프 디버깅을 훨씬 쉽게 만듭니다.
4. Ragas (오픈 소스, 무료)
RAG 파이프라인을 위한 특화된 평가 프레임워크입니다. 충실도, 답변 관련성, 컨텍스트 정밀도, 컨텍스트 재현율을 측정합니다. 3개월 차부터 RAG 시스템을 평가한다면 필수적입니다.
집중해야 할 내용: 예상 출력 또는 평가 기준이 있는 20-50개의 대표 입력으로 구성된 골든 테스트 세트를 구축하고, 출력을 결정론적으로(문자열 일치, JSON 스키마 검증) 또는 LLM-as-judge 방식으로 평가하는 eval 함수를 작성하고, 프롬프트를 변경하거나 모델을 교체할 때 자동으로 eval을 실행하는 것입니다.
중요한 마인드셋: 평가는 선택적인 옵션이 아닙니다. 평가 없이 프롬프트를 변경하거나, 모델을 교체하거나, 검색을 조정하는 것은 도박입니다. 신뢰할 수 있는 AI 제품을 출시하는 엔지니어는 지속적으로 평가를 실행합니다.
8. 작업 성공 메트릭
자동화된 평가 외에도 에이전트가 실제 목표를 달성하고 있는지 알려주는 메트릭이 필요합니다.
리소스:
1. Hamel Husain: 당신의 AI 제품에는 평가가 필요합니다 (무료)
링크: https://hamel.dev/blog/posts/evals/
실제 프로덕션 AI 시스템을 위한 평가 파이프라인 구축에 관한 가장 실용적인 글 중 하나로, 대규모로 이를 수행한 경험이 있는 사람이 작성했습니다.
2. OpenAI Evals 프레임워크 (오픈 소스, 무료)
링크: https://github.com/openai/evals
OpenAI 자체 평가 프레임워크로, 적용할 수 있는 커뮤니티 기여 평가 패턴의 대규모 라이브러리를 포함합니다.
집중해야 할 내용: 프로세스 메트릭(에이전트가 올바른 도구를 호출했는가?)과 결과 메트릭(작업이 성공했는가?)의 차이, 아무것도 구축하기 전에 명확한 성공 기준을 정의하는 것, 그리고 정확한 일치가 어려운 출력(긴 형식의 답변이나 다단계 추론 과정 등)을 평가하기 위해 LLM-as-judge를 사용하는 것입니다.
실습 프로젝트: 3개월 차의 RAG 파이프라인을 가져와 적절한 평가 도구를 구축하세요. 문서에서 30개의 질문-답변 쌍을 만들고, 파이프라인을 통해 실행한 다음, DeepEval을 사용하여 각 답변의 관련성, 충실도, 완전성을 평가하세요. 그런 다음 한 가지(청크 크기, 모델, top-k)를 변경하고 다시 실행하여 개선되었는지 확인하세요.
4개월 차 마일스톤
이번 달 말까지 다음을 할 수 있어야 합니다:
- 에이전트 루프가 무엇인지 설명하고 프레임워크 없이 처음부터 구현하기
- 올바르고 안정적으로 선택되는 도구 설명 작성하기
- LangGraph 또는 이와 동등한 것을 사용하여 에이전트 상태를 적절히 관리하기
- 에이전트 루프 내에서 실패를 처리하면서 중단되지 않도록 하기
- 작업에 에이전트, 워크플로우 또는 단일 프롬프트가 필요한지 자신 있게 결정하기
- LLM 호출을 체이닝, 라우팅, 병렬화하는 다단계 워크플로우 구축하기
- 프롬프트나 모델을 변경할 때 회귀를 포착하는 자동화된 평가 작성하기
- 구축하는 모든 AI 시스템에 대한 작업 성공 메트릭 정의 및 측정하기
⏩------------------------------------------------------------------------⏪
5개월 차: 배포, 제품 사고, 신뢰성
이번 달 목표: 지금까지 구축한 모든 것을 프로덕션에 바로 사용할 수 있도록 만드세요.
마지막까지 실제 사용자, 실제 트래픽, 실제 실패를 처리하면서 새벽 2시에 무너지지 않는 AI 앱을 배포할 수 있어야 합니다.
대부분의 AI 엔지니어가 이 지점에서 멈춥니다. 훌륭한 데모를 만들 수는 있지만 실제 세상과의 접촉을 견딜 수 있는 제품을 출시하지는 못합니다.
여기서의 기술은 회사들이 실제로 비용을 지불하는 것입니다: 안정성, 보안, 비용 관리, 그리고 무언가가 필연적으로 고장 났을 때 계속 실행할 수 있는 능력.
1. FastAPI 프로덕션 패턴
1개월 차에서 FastAPI 앱을 구축하는 방법은 이미 알고 있습니다. 이제 프로덕션 트래픽을 견딜 수 있도록 만들어야 합니다.
개발과 프로덕션의 차이는 가혹합니다. --reload가 있는 단일 uvicorn 프로세스는 구축에는 좋습니다. 프로덕션에서는 실제 트래픽이 도착하는 순간 병목 현상이 발생합니다.
실제로 필요한 것: 멀티 워커 ASGI 설정, 적절한 오류 처리 미들웨어, 상태 확인 엔드포인트, CORS 정책.
리소스:
1. FastAPI 배포 문서 (공식, 무료)
링크: https://fastapi.tiangolo.com/deployment/
Uvicorn 워커, Gunicorn 및 Docker 배포를 다루는 공식 가이드입니다. 다른 것보다 먼저 여기서 시작하세요.
2. FastAPI 프로덕션 배포 가이드 (CYS 문서, 무료)
링크: https://craftyourstartup.com/cys-docs/fastapi-production-deployment/
포괄적인 프로덕션 패턴: Gunicorn 설정, Nginx 리버스 프록시, 상태 확인, 속도 제한. 적용할 수 있는 실제 설정 파일을 포함합니다.
3. 프로덕션을 위한 FastAPI 모범 사례 (FastLaunchAPI, 무료)
링크: https://fastlaunchapi.dev/blog/fastapi-best-practices-production-2026
비동기 데이터베이스 풀링, Redis 캐싱, JWT 인증, 백그라운드 작업을 다룹니다. 100명 이상의 개발자가 사용하는 실제 템플릿에서 가져온 프로덕션 검증 패턴입니다.
집중해야 할 내용: 기본 Uvicorn이 아닌 Uvicorn 워커와 함께 Gunicorn 실행, 상태 확인 엔드포인트 설정, CORS 미들웨어 추가, 적절한 비동기 데이터베이스 세션 구현, 응답을 차단할 필요가 없는 모든 작업에 백그라운드 작업 사용.
2. Docker
Docker는 "내 컴퓨터에서는 작동해요"라는 말을 중단하고 일관된 배포를 시작하는 방법입니다.
AI 앱을 구축하는 경우 Docker는 종속성 충돌을 해결하고, 일관된 환경을 보장하며, 확장을 간단하게 만듭니다.
Docker 전문가가 될 필요는 없습니다. FastAPI + LLM 앱을 컨테이너화하고 어디에든 배포할 수 있으면 됩니다.
리소스:
1. Docker 공식 시작 가이드 (무료)
링크: https://docs.docker.com/get-started/
가장 권위 있는 시작점입니다. 이미지, 컨테이너, Dockerfile, Docker Compose를 다룹니다.
2. freeCodeCamp: Python과 Docker로 멀티 에이전트 AI 시스템 구축 및 배포 방법 (무료)
링크: https://www.freecodecamp.org/news/build-and-deploy-multi-agent-ai-with-python-and-docker/
Docker Compose로 실제 멀티 에이전트 파이프라인을 구축하는 실용적인 종합 튜토리얼입니다. 관심사 분리, cron 스케줄링, 보안 고려 사항을 다룹니다.
3. DataCamp: Docker를 사용하여 LLM 애플리케이션 배포 (무료)
링크: https://www.datacamp.com/tutorial/deploy-llm-applications-using-docker
RAG 파이프라인이 있는 LLM 앱을 위한 단계별 가이드입니다. Dockerfile 생성, 환경 관리, 배포를 다룹니다.
4. LLM 앱을 위한 Docker 컨테이너화 (ApXML, 무료)
기본 이미지 선택, 종속성 관리, 다단계 빌드, 다중 서비스 LLM 배포를 위한 Docker Compose를 다룹니다.
집중해야 할 내용: Python/FastAPI 앱용 Dockerfile 작성, 다단계 빌드로 이미지 크기 유지, 다중 서비스 설정(앱 + 데이터베이스 + Redis)을 위한 Docker Compose, 비밀번호를 위한 환경 변수, 민감한 파일 누출 방지를 위한 .dockerignore.
실습 프로젝트: 3개월 차의 RAG 앱을 컨테이너화하세요. FastAPI 앱, 벡터 데이터베이스(Chroma 또는 Qdrant), 캐싱용 Redis를 실행하는 docker-compose.yml을 만드세요. docker compose up으로 모든 것이 시작되도록 배포하세요.
3. 백그라운드 작업 및 큐
LLM 호출은 느립니다. 사용자가 문서 처리를 요청했는데 30초 동안 응답을 기다리게 하면 떠날 것입니다.
백그라운드 작업을 사용하면 요청을 즉시 수락하고, 비동기적으로 처리한 다음, 완료되면 사용자에게 알릴 수 있습니다.
리소스:
1. Celery 공식 시작 가이드 (무료)
링크: https://docs.celeryq.dev/en/stable/getting-started/introduction.html
표준 Python 작업 큐입니다. 기본 설정, 작업 정의, 작업자 관리를 다룹니다.
2. FastAPI 백그라운드 작업 문서 (공식, 무료)
링크: https://fastapi.tiangolo.com/tutorial/background-tasks/
간단한 사용 사례를 위한 내장 경량 백그라운드 작업입니다. 빠른 실행 후 망각(fire-and-forget) 작업에는 이것을 사용하고, 더 무거운 작업에는 Celery를 사용하십시오.
집중해야 할 내용: FastAPI의 내장 BackgroundTasks와 Celery와 같은 적절한 작업 큐를 사용해야 하는 시기 이해, Redis를 메시지 브로커로 설정, 작업 실패 및 재시도 처리, 작업 상태를 사용자에게 반환.
4. 인증 및 API 키 보안
AI 앱에 API가 있다면 인증이 필요합니다. 인증이 없으면 누구나 엔드포인트를 사용하고 LLM 크레딧을 소진시켜 $5,000 청구서를 받게 될 수 있습니다.
리소스:
1. FastAPI 보안 문서 (공식, 무료)
링크: https://fastapi.tiangolo.com/tutorial/security/
OAuth2, JWT 토큰, API 키, 의존성 기반 인증 패턴을 다룹니다. 공식 참고 자료이며 전체 튜토리얼을 진행하세요.
2. OWASP API Security Top 10 (무료)
링크: https://owasp.org/API-Security/
API 보안 위험의 권위 있는 목록입니다. 아무것도 출시하기 전에 인증 손상, 인젝션, 대량 할당을 이해하세요.
3. Auth0: API Auth 모범 사례 (무료)
링크: https://auth0.com/docs/get-started/authentication-and-authorization
API에서 인증 및 권한 부여를 구현하기 위한 실용적인 가이드입니다.
집중해야 할 내용: 사용자 인증을 위한 JWT 토큰, 서비스 간 통신을 위한 API 키 관리, 사용자/키별 속도 제한, 코드에 비밀번호를 절대 저장하지 않음(환경 변수 사용), 인증(당신은 누구인가)과 권한 부여(무엇을 할 수 있는가)의 차이 이해.
5. 로깅 및 관찰 가능성
프로덕션에서 무슨 일이 일어나고 있는지 볼 수 없으면 고장 난 것을 고칠 수 없습니다.
LLM 앱에는 독특한 도전 과제가 있습니다: 모델이 200 상태 코드를 반환할 수 있지만 여전히 쓸모없거나 환각된 답변을 생성할 수 있습니다. 전통적인 모니터링은 이를 포착하지 못합니다. LLM 특화 관찰 가능성이 필요합니다.
리소스:
1. Langfuse (오픈 소스, 무료 티어)
링크: https://langfuse.com/docs/observability/overview
오픈 소스 LLM 관찰 가능성 플랫폼입니다. 모든 요청을 추적합니다: 보낸 프롬프트, 받은 응답, 토큰 사용량, 지연 시간, 도구 호출. 프롬프트 버전 관리, 평가, LLM-as-judge 점수 생성을 지원합니다. OpenAI, Anthropic, LangChain, LlamaIndex와 통합됩니다.
2. LangSmith (무료 티어)
링크: https://smith.langchain.com/
LangChain 팀에서 제공합니다. LangChain/LangGraph를 사용하는 경우 설정은 하나의 환경 변수면 됩니다. 추적, 디버깅, 모니터링 대시보드, 온라인 평가. 무료 티어는 개발 및 소규모 프로덕션에 충분히 제공됩니다.
3. Python Structlog (무료)
링크: https://www.structlog.org/
Python용 구조화된 로깅 라이브러리입니다. 실제로 검색 및 구문 분석이 가능한 JSON 로그를 생성합니다. 프로덕션 앱의 print() 또는 기본 로깅보다 훨씬 좋습니다.
집중해야 할 내용: 모든 LLM 호출 추적(입력 프롬프트, 출력, 토큰, 지연 시간, 비용), JSON 출력을 사용한 구조화된 로깅, 요청 볼륨, 오류율, 일일 비용을 보여주는 대시보드 설정, 무언가 고장 나거나 비용이 급증할 때 알림.
6. 프롬프트 및 버전 관리
프로덕션에서 프롬프트는 코드입니다. 버전 관리, 테스트, 롤백 기능이 필요합니다.
무엇을 변경했는지 추적하지 않고 프로덕션에서 프롬프트를 변경하는 것은 무언가를 망가뜨리고 이유를 찾을 수 없는 방법입니다.
리소스:
1. Langfuse 프롬프트 관리 (무료)
링크: https://langfuse.com/docs/prompts
내장된 플레이그라운드로 테스트할 수 있는 중앙 집중식 프롬프트 버전 관리입니다. 애플리케이션 코드와 별도로 프롬프트를 버전 관리하세요. 앱을 재배포하지 않고 프롬프트 변경 사항을 배포하세요.
2. Anthropic 프롬프트 관리 모범 사례 (무료)
링크: https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview
프롬프트를 대규모로 구성, 반복, 관리하기 위한 모범 사례입니다.
집중해야 할 내용: 애플리케이션 코드 외부에 프롬프트 저장, 모든 프롬프트 변경 사항 버전 관리, 프로덕션에서 프롬프트 변형 A/B 테스트, 새 프롬프트의 성능이 더 나쁠 때를 대비한 롤백 전략.
7. 비용 모니터링 및 속도 제한
LLM API는 토큰당 비용을 청구합니다. 비용 통제 없이 트래픽 급증이나 프롬프트 버그는 몇 분 만에 수백 달러를 태울 수 있습니다.
리소스:
1. OpenAI 사용량 대시보드 (공식)
링크: https://platform.openai.com/usage
모델별, 일별 지출을 추적하고 사용량 한도를 설정하세요.
2. Anthropic 사용량 대시보드 (공식)
링크: https://console.anthropic.com/Same Claude API 사용량도 동일합니다.
3. Helicone (무료 티어)
모든 LLM 호출을 자동 비용 추적과 함께 캡처하는 프록시 기반 관찰 가능성 도구입니다. 설정은 한 줄의 코드로 충분합니다: 기본 URL만 변경하면 됩니다.
4. LiteLLM (오픈 소스, 무료)
링크: https://github.com/BerriAI/litellm
100개 이상의 LLM 제공자를 위한 통합 인터페이스입니다. 예산 관리, 속도 제한, 제공자 간 지출 추적을 포함합니다.
집중해야 할 내용: 일일/월별 하드 지출 한도 설정, API에서 사용자별 속도 제한 구현, 간단한 작업에는 저렴한 모델 사용(모든 것에 GPT-4/Opus를 사용하지 마세요), Redis로 반복되는 동일 요청 캐싱, 비싼 프롬프트를 조기에 포착하기 위해 요청당 비용 모니터링.
8. 캐싱
사용자의 20%가 비슷한 질문을 한다면 동일한 LLM 호출 비용을 20번 지불하는 것입니다.
캐싱은 비용과 지연 시간을 동시에 줄이는 가장 간단한 방법입니다.
리소스:
1. Redis 공식 문서 (무료)
표준 인메모리 데이터 저장소입니다. 빠르고 간단하며 LLM 응답 캐싱에 완벽하게 작동합니다.
2. GPTCache (오픈 소스, 무료)
링크: https://github.com/zilliztech/GPTCache
LLM 애플리케이션을 위해 특별히 설계된 의미론적 캐싱입니다. 임베딩 유사성을 사용하여 의미적으로 유사한(동일할 뿐만 아니라) 쿼리에 대한 캐시된 응답을 찾습니다.
집중해야 할 내용: 동일한 프롬프트에 대한 정확 일치 캐싱, 유사한 쿼리에 대한 의미론적 캐싱, 캐시 무효화 전략(TTL 기반이 가장 간단함), 실제 비용 절감을 이해하기 위한 캐시 적중률 측정.
5개월 차 마일스톤
이번 달 말까지 다음을 할 수 있어야 합니다:
- 적절한 프로덕션 설정으로 Docker에서 FastAPI + LLM 앱 배포하기
- 백그라운드 작업과 큐로 장기 실행 작업 처리하기
- 인증, 속도 제한, API 키 관리로 API 보안 유지하기
- Langfuse 또는 LangSmith를 사용하여 LLM 호출 추적 및 디버깅하기
- 버전 관리 및 롤백 기능으로 프롬프트 관리하기
- 실시간으로 비용을 모니터링하고 지출 한도 설정하기
- LLM 응답을 캐싱하여 지연 시간과 비용 줄이기
⏩------------------------------------------------------------------------⏪
6개월 차: 전문 분야 선택 및 취업 가능성 확보
지금까지 얻은 지식과 기술은 세 가지 방향으로 적용될 수 있습니다(확실히 제가 보는 것만입니다).
그중 하나를 선택하여 실습에 집중해야 합니다.
위에서 언급한 모든 것도 순전히 실습을 통해 가장 잘 배울 수 있습니다.
방향 1: AI 제품 엔지니어
스타트업 채용을 빠르게 원한다면 가장 좋습니다.
이것은 가장 일반적인 경로입니다. 실제 사용자와 상호 작용하는 AI 기반 제품을 구축합니다.
1~5개월 차의 대부분의 기술은 이미 갖추고 있습니다. 이제 제품 측면을 더 깊이 파고드세요.
집중해야 할 분야:
- LLM 앱
- RAG
- 에이전트
- 배포
- 제품 UX
이번 달에 배울 내용:
1. 종단간 제품 구축
튜토리얼 구축을 중단하세요. 사람들이 사용할 수 있는 제품을 구축하세요.
리소스:
1. Vercel AI SDK (무료)
링크: https://sdk.vercel.ai/docs
스트리밍 지원으로 AI 기반 UI를 구축하는 가장 빠른 방법입니다. 내장 스트리밍 UI 컴포넌트와 함께 React, Next.js, Vue 통합을 제공합니다.
2. Streamlit (무료)
링크: https://docs.streamlit.io/
순수 Python으로 데이터 앱과 AI 데모를 구축합니다. 내부 도구 및 MVP에 이상적이지만 프로덕션 규모 UI에는 적합하지 않습니다.
3. Gradio (무료)
링크: https://www.gradio.app/docsQuick 최소한의 코드로 ML/AI 인터페이스를 구축할 수 있습니다. 특히 모델 데모 및 프로토타입 제작에 유용합니다.
집중할 부분: 이번 달에 데모로 보여줄 수 있는 완성된 프로젝트 2~3개를 구축하세요. "문서와 채팅하는" 앱, AI 기반 내부 도구, 실제 워크플로우를 자동화하는 에이전트 등이 좋습니다. 출시하고, GitHub에 올리고, 사람들이 사용해볼 수 있는 곳에 배포하세요.
2. AI를 위한 제품 UX
AI 제품은 UX가 모델의 한계를 고려하지 않을 때 실패합니다.
자료:
1. Google: People + AI Guidebook (무료)
링크: https://pair.withgoogle.com/guidebook/
인간-AI 상호작용 설계에 관한 최고의 자료입니다. 기대치 설정, 오류 처리, 신뢰 구축 방법을 다룹니다.
2. Nielsen Norman Group: AI UX Guidelines (무료)
링크: https://www.nngroup.com/topic/artificial-intelligence/
연구 기반의 AI 인터페이스 가이드라인입니다.
집중할 부분: 스트리밍 중 로딩 상태를 처리하는 방법, 모델이 틀렸을 때 표시할 내용, 사용자가 피드백을 제공할 수 있도록 하는 방법, 그리고 AI 출력이 확률적이라는 점(때로는 틀릴 수 있음)을 고려한 설계 방법입니다.
방향 2: 응용 ML / LLM 엔지니어
더 깊이 있는 기술적 역할을 원한다면 가장 좋습니다.
이 방향은 API 호출을 넘어 내부 동작 원리를 이해하려는 엔지니어를 위한 것입니다.
집중 분야:
- 파인튜닝
- 파인튜닝과 프롬프트 엔지니어링 중 선택하는 시점
- 평가
- 추론 최적화
- 오픈소스 모델
- 트레이닝 파이프라인
이번 달에 배울 내용:
1. 파인튜닝 vs 프롬프트 엔지니어링 시점
응용 ML에서 가장 중요한 결정: 모델 자체를 변경해야 할까요, 아니면 모델과 대화하는 방식을 변경해야 할까요?
자료:
1. Google ML Crash Course: 파인튜닝, 증류, 프롬프트 엔지니어링 (무료)
링크: https://developers.google.com/machine-learning/crash-course/llm/tuning
세 가지 접근 방식과 각각을 사용해야 하는 시점에 대한 가장 명확한 설명입니다.
2. Codecademy: 프롬프트 엔지니어링 vs 파인튜닝 (무료)
링크: https://www.codecademy.com/article/prompt-engineering-vs-fine-tuning
각 접근 방식에 대한 명확한 사용 사례를 제공하는 실용적인 의사 결정 프레임워크입니다.
3. IBM: RAG vs 파인튜닝 vs 프롬프트 엔지니어링 (무료)
링크: https://www.ibm.com/think/topics/rag-vs-fine-tuning-vs-prompt-engineering
접근 방식을 결합해야 하는 경우를 포함한 완전한 의사 결정 공간을 다룹니다.
암기할 의사 결정 프레임워크: 프롬프트 엔지니어링부터 시작하세요 (가장 저렴하고 빠름). 모델이 특정 데이터에 접근해야 한다면 RAG를 추가하세요. 프롬프트 + RAG만으로 필요한 품질, 일관성, 지연 시간을 달성할 수 없을 때만 파인튜닝하세요.
2. 실제 파인튜닝
파인튜닝이 필요할 때, 그 방법은 다음과 같습니다.
자료:
1. OpenAI Fine-tuning Guide (공식, 무료)
링크: https://platform.openai.com/docs/guides/fine-tuning
파인튜닝을 시작하는 가장 쉬운 방법입니다. JSONL 데이터셋을 업로드하고, 작업을 실행하고, 커스텀 모델을 얻으세요. 나중에 오픈소스 모델로 전환하더라도 워크플로우를 배우기에 좋습니다.
2. HuggingFace Transformers Fine-tuning Tutorial (무료)
링크: https://huggingface.co/docs/transformers/training
오픈소스 모델 작업을 위한 표준 라이브러리입니다. 트레이닝, 평가, 모델 저장을 다룹니다.
3. Unsloth (오픈소스, 무료)
링크: https://github.com/unslothai/unsloth
메모리를 80% 적게 사용하면서 2배 빠른 파인튜닝을 제공합니다. LoRA 및 QLoRA를 기본적으로 지원합니다. 일반 소비자 하드웨어에서 오픈소스 모델을 파인튜닝하는 가장 빠른 방법입니다.
4. LLaMA-Factory (오픈소스, 무료)
링크: https://github.com/hiyouga/LLaMA-Factory
100개 이상의 LLM을 파인튜닝하기 위한 통합 프레임워크입니다. 코드 없이 파인튜닝할 수 있는 웹 UI를 포함합니다. LoRA, QLoRA, 전체 파인튜닝, RLHF, DPO를 지원합니다.
집중할 부분: 트레이닝 데이터셋 준비 (JSONL 형식), LoRA 및 QLoRA 이해 (파라미터 효율적 파인튜닝), OpenAI 또는 HuggingFace에서 파인튜닝 작업 실행, 파인튜닝된 모델을 기본 모델과 비교 평가, 파인튜닝이 비용 대비 효과적이지 않은 경우 인식.
3. 오픈소스 모델
모든 것을 OpenAI나 Anthropic을 통해 처리할 필요는 없습니다. 오픈소스 모델은 완전한 제어권, API 비용 없음, 로컬 실행 기능을 제공합니다.
자료:
1. Ollama (무료)
하나의 명령어로 오픈소스 LLM을 로컬에서 실행합니다. Llama, Mistral, Gemma 등 수십 가지 모델을 지원합니다. 오픈소스 모델을 실험하는 가장 빠른 방법입니다.
2. HuggingFace Model Hub (무료)
링크: https://huggingface.co/models
가장 큰 오픈소스 모델 저장소입니다. 모든 작업에 대한 모델을 탐색, 다운로드, 배포하세요.
3. vLLM (오픈소스, 무료)
링크: https://github.com/vllm-project/vllm
고처리량 LLM 추론 엔진입니다. 기본 HuggingFace 서빙보다 2~4배 빠릅니다. 오픈소스 모델의 프로덕션 서빙 표준입니다.
집중할 부분: 테스트를 위해 Ollama로 모델을 로컬에서 실행, 양자화 (GGUF, GPTQ, AWQ) 이해 및 배포에 중요한 이유 파악, 사용 사례에 대한 오픈소스 모델과 API 모델 벤치마킹, vLLM으로 프로덕션에서 모델 서빙.
4. 추론 최적화
프로덕션에서 모델을 더 빠르고 저렴하게 만드는 방법.
자료:
1. HuggingFace: Optimizing LLM Inference (무료)
링크: https://huggingface.co/docs/transformers/llm_optims
KV-cache 최적화, 양자화, 배치 전략을 다룹니다.
2. NVIDIA TensorRT-LLM (무료)
링크: https://github.com/NVIDIA/TensorRT-LLM
NVIDIA GPU에서 최대 추론 성능을 제공합니다. 대규모 프로덕션 LLM 서빙에서 가장 많이 사용됩니다.
집중할 부분: 처리량을 위한 배치 전략, 메모리 및 비용 절감을 위한 양자화, 더 빠른 생성을 위한 KV-cache 최적화, 추론 워크로드에 적합한 하드웨어 선택.
방향 3: AI 자동화 엔지니어
비즈니스를 위해 즉시 구축하고 싶다면 가장 좋습니다.
이 방향은 AI로 실제 비즈니스 워크플로우를 자동화하는 것입니다. 제품 구축보다는 운영 문제 해결에 중점을 둡니다.
집중 분야:
- 워크플로우 오케스트레이션
- 비즈니스 프로세스 자동화
- 멀티 툴 시스템
- CRM, 문서, 이메일, 고객 지원, 운영 관련 사용 사례
이번 달에 배울 내용:
1. 워크플로우 오케스트레이션
실제 비즈니스 자동화는 거의 단일 LLM 호출로 이루어지지 않습니다. 여러 시스템에 걸친 일련의 작업 체인입니다.
자료:
1. n8n (오픈소스, 자체 호스팅 무료)
AI 노드가 포함된 비주얼 워크플로우 자동화 도구입니다. LLM을 400개 이상의 통합 (Slack, Gmail, Notion, CRM 등)과 연결합니다. AI 자동화를 위한 최고의 노코드/로우코드 옵션입니다.
2. LangGraph: Multi-Agent Workflows (무료)
링크: https://langchain-ai.github.io/langgraph/concepts/multi_agent/
복잡한 멀티 에이전트 시스템을 위한 코드 우선 오케스트레이션입니다. n8n으로 충분하지 않고 완전한 프로그래매틱 제어가 필요할 때 사용합니다.
3. Temporal (오픈소스, 무료)
장기 실행, 내결함성 프로세스를 위한 지속성 워크플로우 엔진입니다. 자동화가 크래시, 재시도, 타임아웃에서 살아남아야 할 때 사용합니다.
집중할 부분: 실패를 우아하게 처리하는 워크플로우 설계, AI를 실제 비즈니스 도구 (이메일, CRM, 데이터베이스, 스프레드시트)에 연결, 사람이 검증하는 절차 구축, 감사 추적을 위한 모든 자동화된 작업 로깅.
2. 비즈니스 프로세스 자동화
AI 자동화의 수익은 특정하고 비용이 많이 드는 비즈니스 문제를 해결하는 데 있습니다.
자료:
1. Zapier AI Actions (무료 티어)
코드 없이 AI를 6,000개 이상의 앱에 연결합니다. 커스텀 솔루션을 구축하기 전에 자동화 프로토타입을 만드는 데 좋습니다.
2. Make (Integromat) (무료 티어)
고급 로직 및 AI 통합 기능을 갖춘 비주얼 자동화 플랫폼입니다. 복잡한 워크플로우에서 Zapier보다 더 강력합니다.
집중할 부분: ROI가 가장 높은 자동화 대상 파악 (일반적으로 반복적이고 시간 소모적이며 규칙 기반인 작업), 인간을 대체하기보다 보강하는 자동화 구축, 실제 절약된 시간과 비용 측정.
3. CRM, 문서, 이메일, 고객 지원 자동화
가장 일반적이고 가장 가치 있는 AI 자동화 사용 사례입니다.
자료:
1. OpenAI Cookbook: AI-Powered Email Processing (무료)
링크: https://github.com/openai/openai-cookbook
AI로 이메일을 분류, 라우팅, 응답하는 패턴입니다.
2. LangChain: Document Processing Pipelines (무료)
링크: https://python.langchain.com/docs/how_to/#document-loaders
80개 이상의 소스에서 문서를 수집하고 처리합니다.
집중할 부분: AI 기반 이메일 분류기 및 자동 응답기 구축, 구조화된 데이터를 추출하는 문서 처리 파이프라인 생성, 지식 베이스에 RAG를 사용하는 고객 지원 챗봇 구축, 기존 CRM 워크플로우 (HubSpot, Salesforce 등)에 AI 통합.
방향 3 실습 프로젝트: 엔드투엔드 리드 자격 평가 시스템을 구축하세요. 다음 기능을 포함해야 합니다:
소스 (CSV, API, 양식)에서 리드를 스크랩하거나 가져옵니다.
LLM을 사용하여 각 리드 조사 (회사 정보, 적합성 평가).
ICP를 기반으로 리드 점수 매기기 및 순위 지정.
개인화된 아웃리치 메시지 초안 작성.
모든 것을 스프레드시트나 CRM에 기록합니다.
이는 기업이 실제로 비용을 지불하는, 팔 수 있는 실제 자동화입니다.
⏩------------------------------------------------------------------------⏪
결론
이 6개월 후에 무엇을 기대할 수 있을까요?
솔직히 말씀드리자면, 엄청난 돈을 기대하지 않는다면
이 로드맵이 6개월 만에 당신을 시니어 AI 엔지니어로 만들어주지는 않을 것입니다
하지만 실제 문제를 해결하는 진짜 AI 시스템을 구축, 출시, 배포할 수 있는 사람으로 만들어줄 것입니다
그리고 바로 지금, 시장이 바로 그것에 돈을 지불하고 있습니다
AI 엔지니어에 대한 수요는 줄어들지 않고 있습니다. 채용 공고는 전년 대비 25% 증가했습니다
PwC는 AI 기술이 필요한 직무가 그렇지 않은 동일 직무보다 56%의 임금 프리미엄을 가진다는 것을 발견했습니다
단 1%의 기업만이 "AI 성숙도"를 갖춘 것으로 간주됩니다. 즉, 99%는 여전히 도움이 필요하다는 뜻입니다. 미국 노동통계국은 2034년까지 26%의 일자리 성장을 예측합니다
이것은 과장된 숫자가 아닙니다. 분석에 기반한 실제 숫자입니다 (Claude에게서 가져옴 ㅋㅋ)
미국에서 풀타임으로 일한다면:
주니어 AI 엔지니어는 연봉 $90,000-$130,000부터 시작합니다
미드레벨 (3-5년) 은 $155,000-$200,000입니다
시니어 역할은 $195,000-$350,000+입니다
Glassdoor (2026년 3월)에 따르면, 평균은 $184,757입니다
미드레벨 대역이 전년 대비 9.2%로 가장 빠르게 성장하고 있습니다. 기업들이 지속적인 감독 없이 프로덕션 AI를 출시할 수 있는 사람을 절실히 필요로 하기 때문입니다
프리랜스가 더 적합하다면:
AI 에이전트 개발은 시간당 $175-$300입니다
RAG 구현은 시간당 $150-$250입니다
LLM 통합은 시간당 $125-$200입니다
Reddit의 한 개발자는 법률 회사를 위한 문서 요약 도구를 2주 만에 구축하고 $8,000를 벌었습니다. 시간당 $150로 주 25시간을 청구하는 프리랜서는 연간 $195,000를 법니다
그리고 제가 이전 게시물에서 이야기한 컨설팅 경로를 간다면, 다음과 같이 청구할 수 있습니다:
비즈니스에 AI 에이전트 설정: $300-$5,000
AI 콘텐츠 관리: 월 $500-$2,000
고객 지원 자동화: $1,000-$4,000
콜드 아웃리치 설정: $500-$2,000
서비스 스펙트럼은 훨씬 더 넓지만, 이 로드맵의 기술을 익히는 순간 당신은 2026년에 이미 수요가 많은 전문가입니다
이것은 실제 일을 하는 실제 사람들의 실제 숫자입니다
이제 제가 여러분이 이 모든 것에서 얻어가길 바라는 것은 이것입니다:
매달 하나의 프로젝트를 선택하고 직접 구축하세요. 읽기만 하지 말고, 튜토리얼을 보지 마세요. 구축하고, 망가뜨리고, 고치고, 배포하고, GitHub에 올리세요. 채용되는 엔지니어들은 공부한 것을 보여주는 것이 아니라 구축한 것을 보여주는 사람들입니다
배운 것을 공유하기 시작하세요. X, LinkedIn, 어디든 글을 쓰세요. 가르치는 것은 배우는 가장 빠른 방법이며 동시에 당신의 평판을 쌓아줍니다. 제가 본 최고의 기회들은 구직 공고에 500개를 지원한 사람들이 아니라, 자신을 알린 사람들에게서 왔습니다
그리고 준비됐다고 느낄 때까지 기다리지 마세요. 절대 준비됐다고 느껴지지 않을 테니까요. "배우고 있다"와 "구축하고 있다" 사이의 간격은 대부분의 사람들이 영원히 갇히는 곳입니다
실제 작동하는 프로젝트를 갖는 즉시 지원하기 시작하고, 프리랜싱을 시작하고, 서비스를 제공하기 시작하세요. 완벽하지 않더라도 괜찮습니다. 시장은 완벽함에 보상하지 않습니다. 시장은 출시할 수 있는 사람에게 보상합니다
6개월은 당신이 실제로 노력한다면 모든 것을 바꾸기에 충분한 시간입니다
그리고 저는 이 글을 읽는 여러분 각자가 할 수 있다고 진심으로 믿습니다
절대 구축을 멈추지 말고, 절대 배우는 것을 멈추지 마세요
이 글이 도움이 되었기를 바랍니다, 여러분 ❤️
