이것이 AI 에이전트를 구축하는 최고의 방법입니다

채널 아이콘
Cole Medin 구독자 78,300명

요약

이 영상은 기존의 단순 가이드들이 제공하는 기본적인 방법을 넘어, pantic AI와 Lang graph라는 두 강력한 프레임워크를 결합하여 AI 에이전트를 구축하는 깊이 있는 방법을 소개한다. 강의는 에이전트의 구조, 의존성 관리, 동적 상태 업데이트와 인간 개입(human in the loop)과 같은 핵심 개념들을 자세하게 설명하며, Archon이라는 오픈소스 프로젝트를 통해 실전 예제를 선보인다. 또한, 에이전트 간의 협업과 비결정적(workflow) 구조를 효과적으로 구현하는 방법 및 향후 확장을 위한 개선점에 대해 논의한다. 강의는 단계별 데모와 코드 walkthrough를 통해 시청자가 보다 체계적으로 AI 에이전트를 구축할 수 있도록 돕는다.

주요 키워드

pantic AI Lang graph Archon AI 에이전트 에이전트 워크플로우 동적 시스템 프롬프트 인간 개입 오케스트레이션

하이라이트

  • 🔑 pantic AI는 Python 기반 에이전트 프레임워크로, 에이전트의 의존성, 정의, 그리고 도구 함수들을 세밀하게 관리할 수 있도록 합니다.
  • ⚡️ Lang graph는 여러 AI 에이전트를 연결해 복잡한 워크플로우를 구성할 수 있는 오케스트레이션 도구로, 저수준 추상화를 제공하여 유연성을 보장합니다.
  • 🌟 Archon 프로젝트는 pantic AI와 Lang graph를 결합하여 AI 에이전트가 다른 에이전트를 구축하도록 설계된 혁신적 오픈소스 플랫폼입니다.
  • 📌 에이전트 구축 프로세스는 초기 스코프 정의(Reasoner), 실제 코드 구현(Coder Agent), 그리고 사용자의 피드백을 반영하는 루프(인간 개입)를 포함합니다.
  • 🚀 데모를 통해 에이전트의 상태 관리, 동적 시스템 프롬프트 삽입, 그리고 메시지 히스토리 관리 등 실제 구현 기법이 상세히 설명됩니다.

용어 설명

pantic AI

Python 기반 AI 에이전트 빌딩 프레임워크로, 에이전트의 의존성, 상호작용 도구, 시스템 프롬프트 등을 관리하는 데 사용됩니다.

Lang graph

여러 AI 에이전트를 연결하여 복잡한 워크플로우를 구성할 수 있도록 도와주는 오케스트레이션 도구로, 낮은 수준의 추상화를 제공합니다.

Archon

pantic AI와 Lang graph를 활용하여 다른 AI 에이전트를 생성하는 에이전트를 구축하는 오픈소스 프로젝트입니다.

Agentic workflow

여러 AI 에이전트가 비결정적 방식으로 협력하여 문제를 해결하는 일련의 프로세스를 의미합니다.

Human in the loop

에이전트의 작업 과정 중 사용자나 인간 운영자가 개입해 피드백을 주고 최종 결과를 승인하는 과정을 말합니다.

[00:00:00] 소개 및 동기

현존하는 단순 가이드들의 한계를 짚으며, 더 강력하고 유연한 에이전트 구축 방법의 필요성을 설명합니다. pantic AI와 Lang graph의 결합이 어떻게 도움이 되는지 개괄합니다.

[00:00] AI 에이전트 개발에 대한 기존 가이드의 한계점을 설명하고, 더 심층적이고 실용적인 접근 방식의 필요성을 강조합니다.
[00:28] 최근 개발한 가장 강력한 AI 에이전트를 소개하며, Pydantic AI와 LangGraph를 결합한 새로운 방식을 제안합니다.
[01:09] Pydantic AI와 LangGraph의 결합이 게임체인저가 될 것이라 설명하고, 앞으로의 교육 내용을 예고합니다.
[01:47] Pydantic AI 프레임워크의 기본 개념과 특징을 소개하며, 문서에 있는 날씨 에이전트 예제를 언급합니다.
[00:02:00] pantic AI 개요

pantic AI 프레임워크의 핵심 구조와 에이전트를 구축하는 3단계(의존성, 에이전트 정의, 도구 구현)에 대해 설명합니다. 이를 통해 다양한 기능을 제어할 수 있는 방법을 제시합니다.

[02:36] Pydantic AI의 세 가지 주요 구성 요소를 설명합니다. 첫째로 API 키와 데이터베이스 연결과 같은 의존성, 둘째로 시스템 프롬프트와 언어 모델을 포함하는 에이전트 정의가 있습니다.
[03:01] 세 번째이자 가장 큰 부분은 도구 함수들로, 데이터베이스 쿼리, Gmail 사용, 날씨 정보 조회 등 실제 작업을 수행하는 기능들입니다.
[03:12] LangGraph는 AI 에이전트 빌더가 아닌 오케스트레이터로서, Pydantic AI로 만든 에이전트들을 워크플로우로 통합하여 함께 작동하게 만듭니다.
[03:50] LangGraph의 중요한 특징은 저수준 추상화입니다. 이는 다른 고수준 프레임워크들과 달리, 개발자에게 더 많은 제어권과 커스터마이징 능력을 제공합니다.
[00:04:00] Lang graph와의 통합

Lang graph가 pantic AI 에이전트들을 연결해 워크플로우를 구성하는 방법을 소개합니다. 에이전트 간의 조건부 라우팅과 전역 상태 관리 등이 강조됩니다.

[04:40] 실제 예시로 LangChain 블로그의 차트 생성 리서치 에이전트를 소개하며, 이는 LangGraph를 사용하여 여러 에이전트들을 효과적으로 연결한 사례입니다.
[05:09] 에이전트 워크플로우의 흐름을 결정하는 화살표들의 규칙을 정의하는 방법을 설명합니다.
[05:16] 알래스카 평균 기온 차트 생성이라는 예시를 통해 연구와 차트 생성에 필요한 복잡한 워크플로우를 설명합니다.
[05:39] 워크플로우의 비결정적 특성을 설명하며, 연구와 차트 생성이 여러 번의 반복이 필요할 수 있음을 강조합니다.
[06:14] LangGraph와 Pydantic AI의 결합이 복잡한 에이전트 워크플로우 구축을 어떻게 단순화하는지 설명합니다.
[06:48] 과잉 엔지니어링에 대한 경고와 함께, 이러한 도구들이 적절한 사용 사례에서는 매우 강력할 수 있다는 점을 강조합니다.
[07:39] LangGraph와 에이전트 워크플로우의 과도한 설계 위험성에 대해 경고하며, LangGraph를 선택한 이유를 설명합니다.
[00:08:14] Archon 프로젝트 및 버전 비교

Archon v1과 v2의 데모를 통해 단순한 pantic AI 에이전트 구현에서 시작해, Lang graph를 활용한 에이전트 간 협업 및 인간 개입 루프를 도입하는 과정을 보여줍니다. 개선점과 확장의 가능성을 논의합니다.

[08:14] Archon이라는 AI 에이전트를 소개하며, 이것이 Pydantic AI와 LangGraph를 활용해 다른 AI 에이전트를 만드는 오픈소스 프로젝트임을 설명합니다.
[09:10] Archon 프로젝트의 발전 계획을 설명하며, 간단한 것부터 시작해 복잡한 기능까지 단계적으로 개발할 것임을 안내합니다.
[09:34] Archon의 버전별 발전 과정을 설명하고, 현재 버전 2의 기능과 향후 계획된 기능들을 소개합니다.
[10:00] 자체 피드백 루프, 도구 라이브러리 통합, 다양한 프레임워크 지원 등 Archon의 미래 비전을 제시합니다.
[10:12] WindSurf나 Cursor 같은 IDE에서 Pydantic AI를 사용할 수 있게 만들고 싶다는 포부를 밝힘. 현재 LLM들이 문서 접근 없이는 프레임워크 사용이 어려운 상황 설명.
[10:34] Archon을 통해 사용하기 쉽고 견고한 시스템을 구축하고, Docker, LangSmith, 다양한 벡터 데이터베이스와의 통합을 계획.
[11:05] Archon의 코드를 GitHub 저장소에 공개하고, 단계적인 학습을 위해 버전별로 문서화할 계획을 설명.
[11:42] 버전 1부터 시작하여 Pydantic AI의 기본 사용법과 한계점을 이해하고, 점진적으로 LangGraph를 도입하는 학습 방식 소개.
[12:11] 각 버전별 README를 통해 구현 내용과 시작 방법을 상세히 설명하고, 순차적 학습이 가능하도록 구성.
[12:45] 버전 1 소개: 이전에 만든 Crawl AI RAG 에이전트를 기반으로 시작하며, 채널에서 이미 다룬 내용을 간단히 설명할 예정입니다.
[13:11] 지식 베이스 구축 과정: 사이트맵을 통해 Pydantic AI 문서를 가져와 Crawl4AI로 처리하고, 청크로 나눈 후 Supabase에 PG Vector로 저장합니다.
[13:41] Pydantic AI 에이전트의 세 가지 구성 요소: 의존성(Supabase, OpenAI), 에이전트 생성 코드, 그리고 에이전트가 사용할 도구들을 설명합니다.
[14:10] 시스템 프롬프트 개선: 단순 질답 에이전트에서 Pydantic AI 문서를 활용하여 새로운 에이전트를 만들 수 있도록 확장했습니다.
[14:50] 도구 기능 설명: RAG 수행과 문서 페이지 목록 확인 등 에이전트가 사용할 수 있는 도구들의 기능을 소개합니다.
[15:14] 에이전트는 세 가지 도구를 활용하여 Pydantic AI 문서에서 필요한 정보를 검색하고 읽을 수 있습니다. 특정 페이지의 내용을 가져와서 에이전트 구현에 필요한 코드를 생성합니다.
[15:42] 스트림릿 인터페이스를 통해 에이전트를 실행할 수 있으며, 이는 Pydantic AI와 스트림릿 통합의 참고 자료로도 활용 가능합니다.
[16:07] Archon V1의 한계를 보여주기 위한 예제로, GitHub 레포지토리 코드 질문 에이전트를 구현해보았습니다.
[16:39] 결과는 기존 AI 모델들보다는 낫지만, 여전히 최적화가 필요합니다. Pydantic AI에 대한 이해는 있으나 완벽한 구현은 아닙니다.
[17:14] 주요 문제점으로 필수 환경 변수(OpenAI API 키, GitHub API 키)와 모델 지정이 누락되어 있어 실제 실행에 제약이 있습니다.
[17:39] 단순한 사용 사례에는 Pydantic AI만으로도 충분할 수 있지만, 이런 복잡한 사례에서는 LangGraph와 같은 추가적인 도구가 필요합니다.
[17:53] 시스템 프롬프트 최적화와 도구 개선의 필요성에 대해 설명하며, Pydantic AI 문서를 정확히 이해하고 사용하기 위한 그래프 기반 접근방식의 중요성을 강조합니다.
[18:13] 그래프 접근방식 외에도 시스템 프롬프트 개선, 다른 분석 도구 사용, GitHub 저장소 활용 등 다양한 최적화 방법이 있음을 설명합니다.
[18:44] Archon 버전 2의 워크플로우 그래프를 소개하며, LangGraph를 통한 워크플로우 시각화의 장점과 설정 방법을 설명합니다.
[19:38] 버전 2에서는 추론 LLM과 여러 Pydantic AI 에이전트들이 협력하여 작업하며, 문서 선택과 코딩 과정에서 반복적인 피드백 루프를 통해 개선됨을 설명합니다.
[20:24] 휴먼 인 더 루프의 중요성을 설명하며, LLM의 환각 문제를 해결하기 위해 사람의 개입이 필요한 이유를 강조합니다.
[20:54] AI 에이전트 개발 과정에서 사용자의 승인과 피드백을 통한 최종 에이전트 생성 과정을 설명합니다.
[21:14] 아콘 V2의 기본 구조와 향후 발전 방향에 대해 설명하며, 환각 문제 해결을 위한 워크플로우 개선 계획을 공유합니다.
[21:44] 아콘 V1과 비교하여 V2의 향상된 기능들을 설명하며, 더 체계적인 파일 구조와 도구 정의, 환경 변수 설정 등의 개선점을 보여줍니다.
[22:45] 판틱 AI와 랭그래프의 통합으로 인한 시너지 효과를 강조하며, 새로운 구현 단계로 넘어갈 것을 예고합니다.
[22:56] 아콘 V2를 처음부터 구축하는 과정을 시작합니다. 이는 랭그래프와 판틱 AI의 심층적인 통합 과정이 될 것입니다.
[23:16] 현재는 OpenAI를 사용하지만, DeepSeek R1과 Qwen 2.5 등의 로컬 LLM으로도 테스트해 좋은 결과를 얻었습니다. 다만 임베딩을 위해 OpenAI는 여전히 필요합니다.
[23:50] 이제 모든 에이전트들을 연결할 그래프를 구축하기 시작합니다. UI를 통해 각 노드의 구성을 시각적으로 보여드리며 설명하겠습니다.
[24:27] 아콘 V2 그래프 구축을 시작하며, 먼저 필요한 패키지들을 임포트하고 환경 설정을 진행합니다.
[25:02] Supabase 연결 설정과 함께, 로깅 모니터링을 위한 Logfire는 추후 설정하기로 하고, base URL을 통해 OpenAI 또는 Ollama 사용을 설정합니다.
[25:24] LLM 설정에 대해 설명하며, API 키가 필요한 OpenAI나 OpenRouter와 달리 Ollama는 로컬에서 실행되어 API 키가 필요없다는 점을 설명합니다.
[25:34] Pydantic AI에서 Ollama 사용 시 스트리밍 지원이 되지 않는 버그가 있어, 출력이 한 번에 표시되는 제한사항에 대해 설명합니다.
[26:12] Reasoner 에이전트를 정의하고 이것이 워크플로우의 첫 번째 노드를 관리하며 AI 에이전트의 범위를 설정하는 역할을 한다고 설명합니다.
[27:00] 라우터 에이전트의 역할에 대해 설명하며, 이것이 대화를 계속할지 종료할지를 결정하는 중요한 역할을 한다고 설명합니다.
[27:37] 마지막 에이전트의 역할에 대해 설명하며, 이것이 대화 요약과 실행 가능한 코드 및 지침을 제공하는 역할을 한다고 설명합니다.
[28:01] AI 에이전트 구축을 위한 기본 설정으로, OpenAI와 Supabase 클라이언트를 설정하고 RAG 기능을 준비합니다.
[28:12] LangGraph에서 그래프의 상태 관리의 중요성을 설명하며, 전역 상태가 모든 노드에서 필요한 정보를 추적하는 방법을 소개합니다.
[29:05] 각 실행마다 독립적인 상태 관리가 가능하며, 동시에 여러 대화를 처리할 수 있는 LangGraph의 특징을 설명합니다.
[29:37] Reasoner를 이용한 첫 번째 노드 정의와 Pydantic AI 문서 페이지를 활용하는 방법을 설명하고, 에이전트 생성을 위한 프롬프트 설정 방법을 소개합니다.
[30:43] Reasoner.do_run을 사용하여 scope를 생성하고 결과를 파일로 저장하는 과정을 설명합니다. GPT-4 Mini를 사용한 이유와 버전 1과의 공정한 비교를 위한 선택에 대해 설명합니다.
[31:25] LangGraph에서 전역 상태를 업데이트하는 방법과 scope 값의 유지 및 관리 방식에 대해 상세히 설명합니다.
[32:19] coder 에이전트 노드 생성 과정과 워크플로우에서의 역할, 그리고 Pydantic AI Coder 에이전트의 구성에 대해 설명합니다.
[33:01] 새로운 의존성 추가와 시스템 프롬프트에 동적으로 scope를 주입하는 방법에 대한 설명을 시작합니다.
[33:28] Pydantic AI에서 @를 사용하여 에이전트를 참조하고, 시스템 프롬프트를 동적으로 설정하는 방법을 설명합니다.
[33:52] 컨텍스트에서 Reasoner의 출력을 참조하여 시스템 프롬프트에 추가하는 방식과 그 이유를 설명합니다.
[34:44] 대화 기록의 저장과 관리 방식, 그리고 Pydantic AI에서 메시지 형식 변환의 필요성에 대해 설명합니다.
[35:39] Ollama 실행 시 writer 개념의 필요성과 LangGraph에서 에이전트를 호출하는 방법을 상세히 설명합니다.
[36:16] 그래프 실행 시 사용자 인터페이스를 통해 입력된 메시지가 처리되는 방식을 설명합니다. 예를 들어 '날씨 에이전트 만들기'와 같은 요청이 들어오면 그래프를 통해 처리됩니다.
[36:55] LangGraph와 Streamlit에서 사용자 메시지를 처리하는 방법을 설명합니다. UI를 통해 입력된 메시지가 그래프의 상태로 전달되어 처리됩니다.
[37:34] 결과 출력 과정에서 스트리밍 처리 방식과 Ollama 사용 시 발생하는 제한사항에 대해 설명합니다. 비동기적 청크 처리를 통해 실시간 출력이 가능합니다.
[38:18] AI 에이전트의 첫 버전이 생성된 후, 사용자 피드백을 받아 대화를 계속할지 에이전트를 개선할지 결정하는 과정을 설명합니다.
[38:40] 대화 기록 관리 방식을 설명합니다. RAG 결과와 도구 호출을 포함한 모든 메시지가 상태에 저장되어 에이전트가 맥락을 유지할 수 있게 합니다.
[39:06] 대화 기록 관리 방식에 대해 설명합니다. 사용자 프롬프트, 새로운 메시지, 도구 호출 등을 포함하여 시간에 따라 대화 기록을 축적하는 방식을 구현합니다.
[39:16] 사람이 개입하는 인터럽트 기능을 추가하는 과정을 설명합니다. 스트림릿 인터페이스를 통해 사용자와 상호작용하는 방식을 구현합니다.
[39:41] LangGraph의 인터럽트 개념을 활용하여 사람이 개입하는 방식을 구현하는 방법을 상세히 설명합니다. 프론트엔드와의 상호작용 방식도 함께 다룹니다.
[40:40] 그래프 실행 재개 과정에 대해 설명합니다. 명령어 사용 방법과 사용자 입력값 처리 방식을 다룹니다.
[41:21] 라우터 에이전트의 역할을 설명합니다. 대화 종료 여부를 결정하고 다음 단계를 판단하는 기능을 구현합니다.
[41:44] 라우터 에이전트를 사용하여 대화 진행 여부를 결정하고, 대화 종료나 코더 에이전트로 분기하는 로직을 구현합니다.
[42:25] 대화 종료 노드를 구현하여 Pydantic AI에 대화 기록을 전달하고, 대화를 요약하며 최종 코드와 실행 지침을 제공합니다.
[43:04] 메시지 처리 과정에서 바이너리 JSON 형식으로 상태를 저장하고, 필요할 때 Pydantic AI가 사용할 수 있는 형식으로 변환합니다.
[43:57] 그래프 구조를 완성하기 위해 범위 정의자, Reasoner LLM, 코더 에이전트, 대화 종료 에이전트 등의 노드들을 추가하고 연결합니다.
[00:51:00] 결론 및 향후 계획

프로젝트의 요약과 향후 Archon의 발전 방향을 제시합니다. 시청자에게 추가 학습 자료와 차후 업데이트에 대한 기대감을 불러일으킵니다.

타임라인 정보가 없습니다.

[00:00] AI 에이전트를 만들 때
[00:01] 인터넷에는 많은 가이드가 있지만
[00:04] 대부분은 기초적인 내용만 다루고
[00:05] 그 이상은 알려주지 않습니다
[00:07] 물론 이런 가이드들도 잘못된 건 아닙니다
[00:09] 이런 기초 가이드들도 매우 유용하고 가치가 있죠
[00:12] 특히 처음 시작하는 분들에게는요
[00:13] 저도 이런 영상을 자주 만듭니다
[00:15] 하지만 여러분은 더 많은 것을 원한다는 걸 알아요
[00:17] 여러분은 AI 에이전트를 만들 때
[00:19] 최고의 방법을 알고 싶어 하시죠
[00:21] 게다가 너무 복잡하지 않은 방법으로요
[00:23] 만약 그렇다면, 오늘 운이 좋으시네요
[00:25] 여러분을 위해 특별한 것을 준비했거든요
[00:27] 지난 며칠 동안
[00:28] 저는 온 열정을 다해 AI 에이전트를 만들었는데
[00:31] 정말 자신 있게 말씀드릴 수 있습니다
[00:33] 제가 지금까지 채널에서 공유한 것 중
[00:35] 가장 강력한 에이전트라고요
[00:37] 오늘 우리는 심층적으로 살펴볼 건데요
[00:39] 제가 가장 좋아하는 에이전트 프레임워크인 Pydantic AI와
[00:42] 놀라운 에이전트 워크플로우 도구인 LangGraph를
[00:44] 함께 사용해서
[00:46] 무한한 가능성을 열어볼 겁니다
[00:48] 이 AI 에이전트 시스템으로 정말 뭐든 만들 수 있죠
[00:51] 실제로 이 영상에서는
[00:53] 다른 AI 에이전트를 만들 수 있는
[00:54] 에이전트를 만들어볼 겁니다. 정말 대단하죠
[00:57] 또한 지난 에이전트 워크플로우 영상에서
[00:59] Pydantic AI와 LangGraph를 사용한 구현을 예고했었는데
[01:02] 많은 분들이 좋은 아이디어라고 해주셨어요
[01:04] 그래서 준비했습니다
[01:07] 제가 볼 때 Pydantic AI와 LangGraph를 함께 쓰는 건
[01:09] 정말 게임체인저입니다
[01:12] 이 영상과 앞으로의 영상들에서
[01:14] 자세히 설명해드릴 건데요
[01:16] 앞으로 나올 영상들에서
[01:18] 아주 명확하게 설명할 겁니다
[01:19] 왜 이 방식을 선택했는지
[01:21] 그리고 이 프레임워크들을 어떻게
[01:24] 함께 활용할 수 있는지 설명드리겠습니다
[01:26] 또한 이런 설정을 사용할 때의 주의사항도
[01:28] 다룰 예정입니다. 코딩을 모르시는 분들도
[01:30] 이해하실 수 있게 설명드리고
[01:32] 에이전트 플로우를 로컬에서
[01:34] 어떻게 실행하는지도 알려드립니다
[01:36] 그리고 제가 앞으로 계획하고 있는
[01:38] 큰 프로젝트들도 공유하려고 합니다
[01:40] 정말 오랜만에 AI 에이전트를 만드는 게 이렇게 재미있네요
[01:43] 정말 흥미진진한 내용이니
[01:45] 바로 시작해보도록 하죠
[01:47] 자, AI 에이전트를 만들기 전에
[01:49] 먼저 기본을 살펴보겠습니다
[01:51] Pydantic AI와 LangGraph가 무엇을 하는지
[01:53] 그리고 왜 이 둘이 잘 어울리는지 알아보죠
[01:56] 먼저 Pydantic AI는
[01:58] 파이썬 에이전트 프레임워크로
[02:00] AI 에이전트를 쉽게 만들 수 있게 해주면서도
[02:03] 우리가 필요한
[02:04] 모든 사용자 정의와 제어를 가능하게 합니다
[02:06] 테스팅, 함수 호출,
[02:08] 채팅 기록 등 모든 것을 관리할 수 있죠
[02:10] 실제로 Pydantic AI를 사용하면
[02:13] 상상할 수 있는 모든 AI 에이전트를 만들 수 있습니다
[02:15] 문서에 보면
[02:18] 정말 좋은 예시가 있는데
[02:20] 제가 자주 참고하는
[02:22] 날씨 에이전트입니다
[02:23] 여기 보시면
[02:24] 문서 링크는 설명란에 있으니
[02:26] 직접 확인해보실 수 있습니다
[02:28] 이 에이전트는 아주 명확하게
[02:30] Pydantic AI로 에이전트를 만들 때
[02:32] 필요한 세 가지 주요 부분을 보여주고
[02:34] 이 세 가지 부분은
[02:36] 다른 프레임워크에도 적용될 수 있는데,
[02:38] 먼저 의존성(dependencies)부터 시작합니다.
[02:40] 이것들은 에이전트가 필요로 하는 것들로
[02:41] API 키나 데이터베이스 연결과 같은
[02:43] 에이전트를 대신해 작업을 수행하는 데 필요한 요소들입니다.
[02:46] 두 번째 부분은
[02:48] 에이전트 자체의 정의로
[02:51] 시스템 프롬프트와
[02:52] 사용할 대규모 언어 모델을 포함합니다.
[02:54] 그리고 Pydantic AI로 만드는 모든 에이전트의
[02:57] 마지막 부분이자
[02:59] 코드의 대부분을 차지하는 것은
[03:01] 실제 도구를 위한 함수들입니다.
[03:04] 이 함수들은 에이전트가
[03:05] 데이터베이스 쿼리, Gmail 사용,
[03:08] 또는 이 경우에는
[03:09] 특정 위치의 날씨를 가져오는 등의 작업을 수행할 수 있게 합니다.
[03:12] 이것이 AI 에이전트 빌더인 Pydantic AI입니다.
[03:15] 다음으로 LangGraph를 살펴보겠습니다.
[03:18] LangGraph는 AI 에이전트를 만드는 프레임워크가 아닙니다.
[03:21] 그렇다면 Pydantic AI와 너무 많이 겹치고
[03:23] 둘 다 사용할 이유가 없을 것입니다.
[03:25] 대신 이것은 오케스트레이터입니다.
[03:27] Pydantic AI로 만든 AI 에이전트들을
[03:30] 워크플로우로 통합하여
[03:32] 함께 작동하게 만들고
[03:34] 같은 문제나
[03:36] 사용자와의 대화에 대해
[03:38] 함께 추론할 수 있게 합니다.
[03:40] 홈페이지를 조금 더
[03:42] 아래로 스크롤하면
[03:43] 잘 설명되어 있는데
[03:45] 표현력이 뛰어나고 커스터마이징 가능한
[03:47] 에이전트 워크플로우 빌더라는 것입니다.
[03:50] LangGraph의 매우 중요한 점은
[03:52] 저수준 추상화를 가지고 있다는 것입니다.
[03:54] 이는 본질적으로
[03:56] 너무 많은 것을 대신해주지 않는다는 의미입니다.
[03:58] Crew AI와 같은 프레임워크들은
[04:00] 고수준 추상화를 가지고 있어서
[04:02] 많은 것을 대신해주기 때문에 멋지지만
[04:05] 결과적으로 적은 코드로도
[04:07] 작동하지만 문제는
[04:09] 이런 종류의 프레임워크를 사용하면
[04:10] 한계에 부딪힐 수 있다는 것입니다.
[04:12] 복잡한 AI 에이전트 개발에 필요한
[04:14] 세밀한 제어와 커스터마이징이
[04:17] 불가능해질 수 있기 때문입니다.
[04:19] 이는 제가 앞서 언급한
[04:20] Pydantic AI와도 연관되는데
[04:22] LangGraph와 Pydantic AI 모두
[04:25] 저수준 추상화를 가지고 있어
[04:27] 필요한 모든 제어가 가능하고
[04:29] 이것이 이 두 도구를 사용하는
[04:31] 가장 중요한 이유입니다.
[04:33] 또한 이들을 함께 사용하면
[04:34] Pydantic AI로 에이전트를 만들고
[04:36] LangGraph로 연결할 수 있습니다.
[04:39] 이것이 바로
[04:40] 이 영상에서 다룰 내용이며
[04:41] LangChain 블로그에서 가져온
[04:44] 간단한 예시가 있습니다.
[04:46] 차트를 생성할 수 있는 리서치 에이전트가 있는데
[04:48] 이것은 LangGraph를 내부적으로 사용하여
[04:50] 이 모든 노드들을 연결합니다.
[04:52] 더 자세히 볼 수 있는 뷰가 있는데
[04:54] 한번 살펴보겠습니다.
[04:56] 연구원, 차트 생성기,
[04:57] 라우터와 같은 이러한 에이전트들은
[05:00] 모두 Pydantic AI로 만든
[05:01] 대규모 언어 모델 에이전트가 될 수 있고
[05:04] LangGraph는 오케스트레이터로서
[05:06] 이 모든 것을 연결하고
[05:08] 작동 방식을 정의합니다.
[05:09] 여기 보이는 모든 화살표들의 규칙을 정의하는데
[05:11] 이 화살표들이 에이전트 워크플로우의 흐름을 결정하게 됩니다
[05:14] 사용자가 요청을 하면, 예를 들어
[05:16] 지난 10년간 알래스카의 평균 기온
[05:18] 차트를 생성해달라는 요청이 들어올 때
[05:19] 연구와 차트 생성 모두를 위해
[05:22] 많은 작업이 필요합니다
[05:24] 첫 번째 메시지는 연구원에게 전달되어
[05:26] 알래스카의 기온 데이터를 수집하는 것과 같은
[05:27] 작업을 수행하게 됩니다
[05:29] 그러면 라우터는 추가 연구가 필요한지
[05:32] 아니면 차트 생성으로 넘어갈 수 있는지를 결정합니다
[05:35] 그리고 최종적으로 사용자에게 답변을 제공하게 됩니다
[05:37] 여기서 볼 수 있듯이
[05:39] 이 전체 흐름은
[05:41] 매우 비결정적입니다
[05:42] 연구원이 첫 시도에서
[05:44] 정확히 필요한 정보를 얻을 수 있다는 보장이 없습니다
[05:47] 차트 생성기로 넘어가서
[05:50] 첫 시도에 완벽한 차트를 생성하고
[05:51] 바로 사용자에게 전달되는 경우는
[05:52] 드물 것입니다
[05:54] 대부분의 경우에는
[05:56] 여러 번의 반복이 필요합니다
[05:57] 연구를 몇 번 더 하거나
[05:59] 차트를 여러 번 다시 생성해야 할 수 있죠
[06:01] LLM이 이러한 추가 작업의
[06:02] 필요성을 판단하는 지능을 가지고 있습니다
[06:04] 이런 비결정적 워크플로우에서
[06:07] 여러 에이전트들을 결합하는 것은
[06:10] LangGraph 같은 도구 없이는
[06:12] 쉽지 않은 일입니다
[06:14] 또한 연구나 차트 생성과 같은 작업을 수행하는
[06:16] 개별 에이전트를 만드는 것도
[06:18] Pydantic AI나 유사한 프레임워크 없이는
[06:20] 어려운 일입니다
[06:22] 이러한 도구들을 결합함으로써
[06:26] 얻을 수 있는 강력한 힘을
[06:27] 이해하기 시작할 수 있습니다
[06:29] 에이전트들은 쉽게 구축되고
[06:31] 흐름도 매우 쉽게 관리됩니다
[06:33] 모든 연결이 LangGraph의
[06:36] 노드와 엣지로 설정되기 때문입니다
[06:38] 이제 이것들을 자세히 살펴보면서
[06:40] 여러분이 잘 이해할 수 있도록
[06:41] 아주 명확하게 설명해드리겠습니다
[06:42] 오늘 Pydantic AI와 LangGraph로
[06:45] 무엇을 만들 것인지 알아보기 전에
[06:46] 한 가지 주의사항을 말씀드리고 싶습니다
[06:48] 이런 그래프 기반 에이전트 워크플로우를
[06:50] 구축할 때 주의할 점이 있습니다
[06:52] Pydantic AI 문서로 돌아가보면
[06:54] LangGraph와 유사한
[06:56] 전용 페이지가 있는데
[06:58] 이런 흐름에 대한 경고 사항이 있습니다
[07:00] 본질적으로 과잉 엔지니어링을 하지 말라는 것입니다
[07:02] 그래프로 구축된 에이전트 워크플로우를 사용할 때
[07:04] 과잉 엔지니어링의 위험이 있고
[07:07] 실제로 구축하려는 것에 비해
[07:08] 과도할 수 있다는 것입니다
[07:11] 그들이 여기서 말하는 것처럼
[07:12] 정말 필요한 경우가 아니라면
[07:14] 네일건을 사용하지 말라는 것입니다
[07:16] 강력한 도구이지만 모든 작업에
[07:18] 적합한 도구는 아닙니다
[07:20] 오늘 우리가 만들 것은
[07:23] 확실히 강력한 도구가 될 것이라 믿습니다
[07:24] 일반적으로 매우 견고한 에이전트 워크플로우를
[07:27] 여러 에이전트들이 함께 작동하는
[07:29] 비결정적인 방식으로 구축하고 싶을 때
[07:31] 정말 좋은 도구입니다
[07:32] 하지만 이것이 모든 것을 해결하는
[07:35] 최종 해결책이라고
[07:37] 주장하고 싶지는 않습니다
[07:39] 모든 것의 해답이라고 말하고 싶지는 않습니다.
[07:41] 대부분의 경우 과도한 설계가 될 수 있다는 점을 강조하고 싶습니다.
[07:44] 그리고 제가 왜 Graphs 대신
[07:45] LangGraph를 사용하는지 궁금하시다면,
[07:47] 단순히 LangGraph가 훨씬 더 발전되어 있고
[07:50] 오늘 사용할 많은 기능들을 가지고 있기 때문입니다.
[07:52] 어쩌면 나중에 Graphs가
[07:53] 제가 전환할 수 있을 만큼 발전할 수도 있죠.
[07:55] 결국 저는 여기서 원칙을 가르치는 것이지
[07:56] 특정 프레임워크에
[07:58] 얽매이지 않으려고 합니다.
[07:59] 하지만 지금은 LangGraph를 사용하고 있습니다.
[08:01] 이것이 제가 드리는 공정한 경고입니다만,
[08:03] 너무 걱정하지 마세요.
[08:05] 그래프와 에이전트 워크플로우는
[08:08] 여전히 많은 사용 사례에서
[08:10] 매우 강력하니까요. 이제
[08:12] 본격적으로 들어가 보겠습니다.
[08:14] Archon을 소개합니다. 이것은 다른 AI 에이전트를 만드는
[08:17] AI 에이전트로, 예상하셨듯이
[08:20] Pydantic AI와 LangGraph로 구동됩니다.
[08:23] 이것을 완전히 무료로 오픈소스로
[08:25] 두 가지 큰 이유로 만들고 있습니다.
[08:27] 첫 번째는 이 에이전트가 실제로
[08:30] LangGraph와 Pydantic AI를 사용하는
[08:33] 다른 AI 에이전트들을 만들어내기 때문에,
[08:35] 프로그래머가 아니더라도
[08:37] 이 프레임워크들을 사용하여
[08:39] 제가 여기서 가르치는 모든 것을 만들 수 있습니다.
[08:41] 그래서 실제로 시간이 지나면서
[08:43] 이것을 더욱 강력한 것으로
[08:45] 발전시켜 나갈 예정이고, 이는
[08:47] 제가 이것을 만드는 두 번째 이유와 연결됩니다.
[08:48] 결국 Pydantic AI와 LangGraph는
[08:50] 둘 다 사용하기 꽤 쉽지만,
[08:52] 이 둘을 결합해서 만들 수 있는 것들은
[08:54] 매우 강력하면서도
[08:56] 더 복잡해질 수 있습니다.
[08:58] 그래서 단 하나의 유튜브 영상으로
[09:00] 완벽한 에이전트 워크플로우를 만들어
[09:02] 이 두 프레임워크를 사용해서
[09:04] 여러분과 공유하기는 쉽지 않습니다.
[09:06] 대신 Archon은
[09:09] 제가
[09:10] 반복적으로 개발해 나갈 것이며,
[09:12] Pydantic AI와 LangGraph를 가르치는 방법으로 활용될 것입니다.
[09:15] 간단한 것부터 시작해서
[09:17] 시간이 지날수록 더 복잡해질 것이고
[09:18] 앞으로의 영상들을 통해 따라오실 수 있습니다.
[09:21] 간단한 것부터 시작해서
[09:23] 이 두 프레임워크의 마스터가 되는
[09:24] 수준까지 함께 발전해 나갈 수 있습니다.
[09:27] 현재 우리는 버전 2에 있고,
[09:29] 오늘 제가 보여드릴
[09:29] LangGraph와 Pydantic AI로
[09:31] 구축하는 방법을 설명드리겠습니다.
[09:34] 여기 있는 버전 1은 단순한 Pydantic AI 에이전트입니다.
[09:38] LangGraph는 없고, 다른 Pydantic AI
[09:40] 에이전트만 만들 수 있습니다.
[09:42] 이 영상에서 다룰 버전 2는
[09:44] 두 프레임워크로 구축된
[09:46] 에이전트 워크플로우를 활용하여
[09:48] Pydantic AI 에이전트만 만들 수 있습니다.
[09:50] 아직은 꽤 단순하지만,
[09:52] 에이전트 워크플로우를 시작하고 있고,
[09:54] 앞으로는 Pydantic AI와
[09:56] LangGraph 에이전트 모두를 만들 수 있게 될 것입니다.
[09:58] 그리고 제가 가진
[10:00] 미래 반복을 위한 다른 아이디어들도 있습니다.
[10:02] 자체 피드백 루프, 도구 라이브러리 통합,
[10:05] LangChain 같은 다른 프레임워크들,
[10:06] Llama Index와 Crew AI 자율 프레임워크 학습 지원 등
[10:09] 정말 많은 아이디어가 있습니다.
[10:10] 궁극적으로는
[10:12] 이것을 실제로 WindSurf나
[10:14] Cursor와 같은 IDE에서 사용할 수 있는 것으로
[10:17] 바꾸고 싶어요. 정말 멋질 것 같습니다.
[10:19] 현재 이러한 도구들을 사용할 때
[10:21] Pydantic AI로 개발하려고 하면 완전히
[10:23] 환각 상태가 되버립니다. LLM들이
[10:25] Archon과 같은 에이전트 없이
[10:28] Pydantic AI 문서에 접근하지 못하면
[10:30] 이러한 프레임워크로 코딩하는 방법을
[10:32] 알지 못하기 때문입니다.
[10:34] 그래서 이것이 바로 제가 Archon을 통해
[10:36] 궁극적으로 만들고 싶은
[10:37] 매우 사용하기 쉽고 견고한 가치입니다.
[10:40] 그리고 미래에는
[10:41] 배포를 위한 Docker나
[10:43] LangSmith, MCP 같은 다른 프레임워크들,
[10:46] 다른 벡터 데이터베이스들,
[10:48] Supabase 외에도 많은 아이디어들이 있습니다.
[10:50] 저는 이 프로젝트가 정말 기대됩니다.
[10:52] 에이전트 구축을 도와줄 수 있다는 점에서도 그렇고
[10:55] 또한 제가 여러분들에게
[10:57] 명확하고 간결한 방식으로
[10:59] 반복적으로 이 두 프레임워크를
[11:01] 사용하는 방법을 가르칠 수 있고
[11:03] 놀라운 일들을 할 수 있기 때문입니다.
[11:05] 자, 이제 Archon의 코드를 살펴보고
[11:07] Pydantic AI와 LangGraph로 멋진 것들을 만들어봅시다.
[11:11] 우리가 살펴볼
[11:12] 모든 코드는 제가 여러분과 함께 만들 것이고
[11:14] 방금 보여드린 Archon GitHub 저장소에
[11:16] 있을 것입니다. 물론
[11:18] 설명란에도
[11:19] 링크를 넣어두겠습니다.
[11:21] 약속드린 대로
[11:23] Archon을 반복적으로 만들어가면서
[11:25] Pydantic AI의 기초적인 작동 방식과
[11:28] LangGraph가 어떻게 작동하고
[11:29] 함께 어떻게 동작하는지,
[11:31] 그리고 왜 이러한 복잡한
[11:33] 에이전트 워크플로우 접근 방식을
[11:36] 그래프와 함께 사용하고 싶은지,
[11:37] 또는 언제 단순하게 유지하고 싶은지
[11:40] 이해할 수 있을 것입니다.
[11:42] 여기 버전 1부터 시작하겠습니다.
[11:44] Pydantic AI와 LangGraph의 핵심으로
[11:46] 바로 들어가지 않는 이유는
[11:48] 버전 1이 먼저 Pydantic AI만으로
[11:50] 에이전트를 만드는 좋은 예시가 될 것이고
[11:52] 더 중요한 것은
[11:55] 그 한계점들을 살펴보면서
[11:56] 왜 우리가 더 복잡한
[11:58] 다음 버전의 Archon으로
[12:00] 발전해야 하는지 이해할 수 있기 때문입니다.
[12:03] 시간이 지나면서 계속 만들어갈
[12:05] 다음 버전들은 LangGraph도
[12:07] 활용하게 될 것입니다. 버전 1
[12:09] 폴더에 보시면
[12:11] README 파일이 있는데
[12:13] 이 버전의 Archon을 시작하는 방법과
[12:15] 이 버전에서 구현된 내용들을
[12:17] 정확히 설명하고 있습니다.
[12:19] 앞으로도 모든 버전에 대해
[12:22] 이런 설명을 제공할 것이고
[12:23] 여기 iterations 폴더에
[12:25] 모든 코드도 함께 제공될 것입니다.
[12:28] 그래서 여러분이 어느 시점에
[12:30] Archon 여정에 참여하시든
[12:32] 버전 6이더라도
[12:33] 모든 버전을 순차적으로
[12:35] 살펴보면서 기초부터 쌓아올릴 수 있습니다.
[12:37] 간단하게 시작해서
[12:39] 현재 버전까지 올라오면서
[12:41] 점점 복잡해지도록 했습니다.
[12:43] 깊은 물에 바로 뛰어들 필요 없이
[12:45] 이것이 바로 제가
[12:46] 이것을 단계적으로 만드는 목적이고
[12:48] 그래서 우리는
[12:50] 버전 1부터 시작할 것입니다.
[12:52] 이는 제가 이전에 만든 크롤 AI RAG 에이전트를
[12:55] 제 채널에서 이미 만든 것을
[12:56] 기반으로 합니다. 버전 1은
[12:58] 빠르게 설명하겠습니다.
[13:00] 이미 제 채널에서
[13:01] 다뤘기 때문입니다. 해당 영상을
[13:02] 꼭 확인해보세요. 물론 필수는 아니고
[13:04] 여기서도 간단히 설명하겠습니다.
[13:06] 전반적으로 매우 기본적이지만
[13:08] Pydantic AI 에이전트를 만드는 좋은 예시입니다.
[13:11] 지식 베이스를 설정하는 방법은
[13:13] 다른 영상에서처럼
[13:15] 사이트맵을 사용해서 Pydantic AI 문서 페이지를
[13:17] 가져온 다음 리스트로 만들어서
[13:19] Crawl4AI에 전달하여
[13:22] 모든 내용을 마크다운으로 가져오고
[13:24] 이를 청크로 나눈 다음
[13:26] Supabase에 저장합니다.
[13:29] 이렇게 하면 PG Vector를 사용하여
[13:31] RAG용 지식 베이스가 구축됩니다.
[13:34] 이 스크립트는 전혀 변경하지 않았고
[13:35] README에서 실행 방법과
[13:37] 데이터베이스 설정 방법을
[13:39] 모두 설명하고 있습니다.
[13:41] Pydantic AI 에이전트에는
[13:43] 세 가지 주요 부분이 있습니다.
[13:46] 먼저 의존성인데, 이 경우에는
[13:48] RAG를 위한 Supabase와
[13:50] 임베딩 생성을 위한
[13:52] OpenAI 클라이언트가 필요합니다.
[13:55] 두 번째로 여기 있는 것처럼
[13:57] 실제 에이전트 생성 부분이 있고
[13:59] 나머지 코드는
[14:00] 세 번째 부분으로 에이전트에게 제공할
[14:02] 도구들입니다.
[14:04] 이 도구들을 통해 에이전트는
[14:05] 데이터베이스를 검색하고
[14:07] RAG를 수행할 수 있습니다. 또 다른 중요한 것은
[14:10] 이 거대한 시스템 프롬프트입니다.
[14:12] 이것이 제가 크게
[14:14] 리팩토링한 부분인데, 원래는
[14:16] Crawl for AI RAG 에이전트가 단순히
[14:19] Pydantic AI 문서에 대한
[14:20] 질문에 답변만 했지만, 이제는
[14:23] 문서를 활용하여 다른
[14:25] Pydantic AI 에이전트를 만드는 데
[14:27] 사용하고 싶어서
[14:29] 시스템 프롬프트에서 그렇게 지시했습니다.
[14:31] 제공된 도구를 사용하여
[14:34] 문서를 가져와서
[14:35] Pydantic AI 에이전트를 만드는 것이
[14:38] 목표입니다. 각 에이전트에 대해
[14:39] 생성할 파일들의 기본 구조를 정의하고
[14:42] 또한 많은
[14:43] 기타 지침들을 포함했는데,
[14:45] 이는 환각 현상을 방지하고
[14:46] 제공된 도구를 사용하도록
[14:48] 하기 위해서입니다.
[14:50] 이렇게 하면 문서를 기반으로
[14:51] 진실성을 확보할 수 있고
[14:53] Pydantic AI에 대해 임의로 내용을 만들어내지 않습니다.
[14:56] 여기 있는 함수를 사용하여
[14:58] 벡터 데이터베이스의 특정 청크와
[15:00] 매칭하여 RAG를 수행할 수 있고
[15:02] 또한 사용 가능한 모든
[15:04] 문서 페이지를 나열하는 도구도 있습니다.
[15:06] RAG만 수행하는 것이 아니라
[15:07] 전체 문서 페이지를
[15:09] 읽고 싶을 때는 이 도구를 사용해서
[15:12] 어떤 페이지들이 있는지 알 수 있죠.
[15:14] 그리고 여기서 우리의 세 번째이자 마지막
[15:16] 도구를 사용하여 특정 페이지의
[15:18] 내용을 가져올 수 있습니다. 예를 들어
[15:19] Pydantic AI 문서의 예제나
[15:22] 도구 정의에 대해 설명하는
[15:23] 페이지를 읽고 싶을 수 있죠.
[15:25] 이 기능을 사용하여 실제로
[15:27] 그렇게 할 수 있습니다. 이 에이전트는
[15:29] 이 세 가지 도구를 지능적으로 함께 사용하여
[15:32] 필요하다고 생각하는 모든
[15:33] 문서를 가져와서 우리가 정의한
[15:36] 이 구조에 맞는
[15:37] Pydantic AI 에이전트를 생성하는데
[15:40] 필요한 모든 코드를 제공합니다.
[15:42] 이제 이 에이전트를 실행하기 위해
[15:45] readme로 돌아가보면, 제가 설정한
[15:47] 스트림릿 인터페이스가 있는데
[15:48] 지금은 자세히 설명하지 않겠습니다.
[15:51] 매우 기본적인 Pydantic AI 에이전트용
[15:54] 스트림릿 인터페이스입니다.
[15:55] 참고로 이것을
[15:57] Pydantic AI와 스트림릿을 함께 사용하는
[15:59] 참고 자료로 활용할 수 있습니다.
[16:02] 여기 있는 명령어를
[16:03] 실행하면 인터페이스가 시작되는데
[16:05] 저는 이미 실행해 놓은 상태입니다.
[16:07] 제가 Archon V1을 사용했던
[16:09] 예제 실행을 보여드리려고 합니다.
[16:12] 이를 통해 이 버전의 한계를 보여주고
[16:14] 왜 우리가 버전 2로 넘어가야 하는지
[16:17] 설명하려고 합니다. 그리고 나서
[16:18] Pydantic AI와 LangGraph를 함께
[16:20] 사용하여 이를 구축하는 방법을 보여드리겠습니다.
[16:23] 이 에이전트의 예시로, 저는
[16:25] GitHub 레포지토리의 코드에 대해
[16:27] 질문할 수 있는 에이전트를 만들어달라고
[16:29] URL만 제공하면 되도록 요청했습니다.
[16:31] 본질적으로 제가 YouTube 시리즈에서
[16:33] 만들었던 GitHub 에이전트와
[16:35] AI 에이전트 구축 방법을 보여주는
[16:37] 것과 같은 것인데, 이로부터 얻은
[16:39] 결과는 그저 그런 수준입니다.
[16:41] 물론 Claude나 GPT, DeepSeek 등에
[16:44] Pydantic AI로 AI 에이전트를 만들어달라고
[16:46] 요청하는 것보다는 나은데요,
[16:49] 그들은 Pydantic AI에 대한
[16:51] 맥락을 전혀 모르고
[16:53] 문서도 이해하지 못하니까요. 적어도 이 에이전트는
[16:55] 문서를 이해하고 있고, 함수 데코레이터와
[16:58] 같은 것들을 설정하는 방식을 보면
[17:00] Pydantic AI를 이해하고 있다는 것을
[17:01] 확실히 알 수 있습니다. 하지만
[17:04] 결과가 바로 실행되지는 않을 거예요.
[17:06] 에이전트가 제대로 정의되지 않았고
[17:07] 도구들도 최적화되어 보이지 않습니다.
[17:09] 의존성은 괜찮아 보이지만, 중요한 점은
[17:12] 환경 변수가 필요하다는 언급이
[17:14] 없다는 것입니다. 분명히
[17:15] OpenAI API 키가 필요한데도요.
[17:17] 실제로 사용할 모델도 명시하지 않았네요.
[17:21] 이건 확실히 문제가 있고,
[17:22] GitHub API 키도 필요할 것 같습니다.
[17:24] 공개 레포지토리만 클론하는 게 아니라면요.
[17:27] 전반적으로 이상적인 구현이
[17:29] 아닙니다. 어느 정도는 작동하고
[17:31] AI 에이전트에 대한 특정 사용 사례가
[17:33] 단순하고 Pydantic AI만으로도 충분한 경우라면
[17:37] LangGraph를 추가로 사용할 필요는
[17:39] 없을 것입니다. 하지만 이 사용 사례에서는
[17:42] 추가적인 복잡성이 필요하다는 것을
[17:45] 확인할 수 있습니다. LangGraph 없이는
[17:47] 부족해 보이네요.
[17:50] 이 특정 사용 사례에서는
[17:53] 시스템 프롬프트를 더 최적화하거나
[17:55] 더 나은 도구를 사용하는 등의
[17:57] 추가적인 개선이 분명히 필요합니다. 그래서
[17:59] 그래프 기반 접근방식과 에이전트
[18:01] 워크플로우를 통해 Pydantic AI
[18:03] 문서를 정확하게 읽고
[18:04] 올바르게 사용하도록 하는 것이
[18:06] 매우 매우 중요합니다.
[18:10] 그래서 제가 지금부터 보여드릴
[18:11] 내용에 대해 말씀드리고 싶은 것은
[18:13] 그래프 접근방식 외에도 다른 최적화 방법이
[18:15] 있을 수 있다는 점입니다.
[18:18] 예를 들어, 더 나은 시스템 프롬프트나
[18:20] 문서를 다르게 분석하는
[18:22] 다른 도구들을 사용하거나
[18:24] Pydantic AI GitHub
[18:26] 저장소를 가져오는 것도 가능합니다.
[18:27] 지금은 문서 페이지만 있지만
[18:30] 이러한 작업들도 그래프 접근방식으로
[18:32] 전환하는 것만큼의 노력이 필요할 수 있으며
[18:34] 저는 Archon 버전 2에서
[18:35] 매우 좋은 결과를 얻고 있습니다.
[18:37] 이러한 맥락에서 왜 우리가
[18:40] 이것이 필요한지 이해했으니
[18:42] 이제 Pydantic AI와 LangGraph를 함께 사용해
[18:44] 버전 2를 만들어보겠습니다.
[18:47] 이것이 우리가 만들려고 하는
[18:49] Archon의 에이전트 워크플로우 그래프입니다.
[18:52] LangGraph를 사용하면
[18:53] 추가 작업 없이도 워크플로우를
[18:55] 시각화할 수 있다는 것이 장점입니다.
[18:57] 제가 직접 만들지 않았고
[18:59] 여러분도 할 수 있는데
[19:01] Archon 버전 2를 GitHub 저장소에서
[19:03] 가져오거나 녹화 시점 기준
[19:05] 저장소의 루트에서
[19:07] README를 따라 모든 것을 설정하고
[19:09] Python 환경을 설정한 다음
[19:10] langraph dev 명령어를 실행하면
[19:12] 스튜디오 UI가 자동으로 브라우저에서 열립니다.
[19:15] 그러면 바로 이것을 보실 수 있는데
[19:17] 제가 지금부터 처음부터 만들어볼
[19:18] 워크플로우의 모든 노드를
[19:20] 시각화해서 볼 수 있습니다.
[19:22] 보시다시피 더 많은 작업이
[19:24] 이루어지고 있는데
[19:26] 기본적으로 버전 1은
[19:28] 여기 코더 에이전트만 있었습니다.
[19:30] 에이전트를 만들어달라는
[19:31] 요청이 들어오면 이 에이전트가 RAG를 수행하고
[19:34] 특정 문서 페이지들을 살펴보면서
[19:36] 최종 에이전트를 만들어냈습니다.
[19:38] 하지만 이제 버전 2에서는
[19:40] LangGraph와 함께 여러 Pydantic AI
[19:43] 에이전트들이 관여합니다. 우선
[19:45] 워크플로우 시작 부분에서
[19:48] DeepSeek-Coder나 OpenAI GPT-3.5와 같은
[19:50] 추론 LLM을 사용하고 있습니다.
[19:53] 이 에이전트는 사용자의 요구사항,
[19:55] 즉 만들고 싶은 에이전트에 대한
[19:56] 요구사항을 받아 전체 범위 문서를 작성하고
[19:59] 필요한 모든 것을 개략적으로
[20:00] 설명하면서 주요 코더 에이전트가
[20:02] 사용해야 할 Pydantic AI 문서 페이지들을
[20:05] 선택합니다.
[20:07] RAG를 통해 에이전트를 만드는 데
[20:10] 필요한 올바른 맥락을
[20:11] 가질 수 있도록 하고
[20:13] 이것만으로도 결과가 많이 개선됩니다.
[20:15] 그리고 여기 이 루프가 있는데
[20:18] 에이전트가 다른 Pydantic AI 에이전트를 코딩하고
[20:20] 사용자로부터 피드백을 받아
[20:22] 반복 개선하는 과정입니다.
[20:24] 사용자가 최종적으로 결정할 때까지
[20:26] 그렇죠, 좋은 에이전트가 만들어졌으니 다음으로 넘어가죠
[20:28] 이것은 랭그래프의 매우 중요한
[20:30] 개념을 사용하는 것인데, 다른 에이전트
[20:32] 워크플로우 도구에서 '휴먼 인 더 루프'라고 불립니다
[20:34] 이것은 제가 정말 보여드리고 싶은
[20:36] 것인데요, LLM이
[20:38] 항상 환각을 일으키기 때문에
[20:39] 실제로 여러분이 만들고 싶은 모든 AI 에이전트에는
[20:41] 어떤 형태로든 사람의 개입이 필요합니다
[20:44] 다음 단계로 넘어가기 전에 특정 작업을
[20:46] 승인하고
[20:48] 워크플로우에서 피드백을 제공하는 등의
[20:51] 작업이 필요한데
[20:52] 지금 바로 그것을 보여드리겠습니다
[20:54] 사용자가 AI 에이전트가 좋다고 하면
[20:56] 마지막 에이전트가
[20:58] 대화를 마무리하면서
[20:59] 모든 것을 요약하고
[21:01] 실행 지침까지 함께 제공합니다
[21:04] 전반적으로 이것은 랭그래프의
[21:06] 매우 기본적인 구현이지만
[21:08] 아콘 버전 2에서 시작하고 싶은 부분입니다
[21:10] 이 그래프의 전반적인 구조에서
[21:12] 제가 선택한 많은 것들은
[21:14] 여러분에게 가르치고 싶은 개념들을
[21:16] 보여주기 위한 것입니다
[21:19] 휴먼 인 더 루프같은 개념들이요
[21:21] 그리고 앞으로의 아콘 버전에서
[21:22] 실제로 가장 잘 작동하는 것들에
[21:24] 초점을 맞추고
[21:26] 에이전트 생성시 발생하는
[21:28] 다양한 환각을 피할 수 있는
[21:30] 완전한 워크플로우로 발전시킬 것입니다
[21:32] 환각을 피하면서
[21:33] 에이전트를 만들고 그런 것들이죠
[21:35] 지금은 단순하게 시작하지만
[21:37] 훨씬 더 나은 결과를 얻을 수 있습니다
[21:39] 빠르게 보여드리겠습니다. 아콘 버전 1에
[21:42] 했던 것과 동일한 질문을 했는데
[21:44] 이번에는 확실히 더 나은 결과를 얻었습니다
[21:47] 우선 초기에 작은 분석까지 받았는데
[21:49] 약간의 분석도 받았고
[21:50] 정말 놀라운 점은
[21:52] Reasoner에서 코더로 범위 문서를
[21:54] 전달한다는 것 자체가
[21:57] 더 강력한 응답을 제공하기 위한
[21:59] 훨씬 더 많은 정보를 가지고 있다는 것입니다
[22:01] 여기서 파일 구조를 받고
[22:03] 코드 구현도 받았는데, 도구들이
[22:05] 훨씬 더 좋아 보입니다
[22:07] 에이전트를 정의하고 실제로 LLM을
[22:09] 지정했네요. GPT-4.0이
[22:11] 우리가 원하는 선택은 아닐 수 있지만
[22:14] 올바르게 정의되었고
[22:16] 도구들이 채워졌고, 프롬프트 파일도
[22:19] 채워졌으며, 환경 변수들도
[22:21] 이번에는 실제로 의미가 있습니다
[22:23] 아직 완벽하지는 않지만
[22:26] 훨씬 더 나아 보이고
[22:27] 추가 지침까지 제공합니다
[22:30] 아콘 V1에 비해 이 응답을 제공하는 데
[22:32] 훨씬 더 많은 것이 포함되어 있다는 것을
[22:34] 알 수 있습니다. 이 모든 것이 아콘 V1에 비해
[22:37] 이 에이전트 흐름 덕분인데, Reasoner가 있고
[22:39] 피드백 루프가 있으며
[22:42] 마지막에는 모든 것을 요약하고
[22:43] 지침을 제공할 수 있는 에이전트가 있습니다
[22:45] 이제 이를 염두에 두고
[22:47] 판틱 AI와 랭그래프를 함께 사용하는
[22:50] 힘을 실제로 볼 수 있습니다
[22:52] 이제 이 그래프를
[22:53] 처음부터 구현해 보겠습니다
[22:56] 이제 함께 아콘 V2를 만들어보겠습니다.
[22:58] 완전히 처음부터 시작하겠습니다.
[23:00] 앞서 약속드린 대로
[23:02] 이것은 랭그래프에 대한
[23:04] 진정한 심층 탐구가 될 것이며
[23:06] 판틱 AI와의 통합도 다룰 예정입니다.
[23:09] V1과 마찬가지로 README 파일이 있어서
[23:11] 모든 설정 방법이 설명되어 있습니다.
[23:13] 로컬 실행 방법도 포함되어 있죠.
[23:16] 시간을 절약하기 위해
[23:17] 지금은 OpenAI를 사용하겠지만
[23:19] 이 에이전트를 DeepSeek R1 Distill 7B를
[23:21] 추론 모델로 테스트해봤고
[23:24] Qwen 2.5 Instruct 14B를 코딩 모델로 사용해봤는데
[23:28] 정말 뛰어난 성능을 보여줬습니다.
[23:29] 로컬 LLM으로 아주 좋은 결과를 얻었죠.
[23:31] 한 가지 말씀드릴 것은
[23:33] 임베딩 모델을 위해서는 여전히
[23:35] OpenAI가 필요하다는 점입니다.
[23:38] 이 의존성은 아콘의
[23:39] 향후 버전에서 제거할 예정이에요.
[23:41] 완전히 로컬에서 실행할 수 있도록 말이죠.
[23:43] 에이전트들은 로컬로 실행할 수 있고
[23:45] 아주 좋은 결과를 얻었습니다.
[23:46] README를 따라 V1처럼
[23:48] 모든 것을 설정하시면 됩니다.
[23:50] 설정해야 할 다른 것들도 있지만
[23:51] 우리가 처음부터 만들
[23:52] 것은 모든 에이전트들을 연결할
[23:55] 그래프입니다.
[23:57] 판틱 AI 코더 에이전트를 포함해서
[24:00] 이 워크플로우의 핵심 에이전트로
[24:02] 여전히 가지고 있는 것들을 연결할 거예요.
[24:05] 그래프를 만들면서
[24:06] 이 UI를 보여드리며 만들고 있는
[24:09] 다양한 노드들을 설명하겠습니다.
[24:10] 이를 시각적 참조로 사용해서
[24:12] 전체 과정을 최대한 명확하게
[24:15] 설명하려고 합니다. 비록 이것이
[24:17] 비교적 간단한 랭그래프 구현이지만
[24:19] 여전히 많은 움직이는 부분들이 있고
[24:21] 만들고 작업해야 할
[24:22] 다양한 에이전트들이 있기 때문에
[24:24] 이것을 많이 사용할 것이고
[24:25] 명확하게 보여드리도록 하겠습니다.
[24:27] 자, 이제 아콘 V2를 위한
[24:29] 그래프 만들기를 시작해보죠.
[24:31] 제 파이썬 스크립트가 항상 패키지 임포트로
[24:33] 시작한다고 100달러를 걸었다면
[24:35] 모든 튜토리얼에서 100달러를 벌 수 있을 겁니다.
[24:37] 여기 있는 모든 튜토리얼이
[24:39] 그렇거든요. 먼저 랭그래프와
[24:41] 판틱 AI에 필요한 모든 패키지를
[24:43] 임포트하겠습니다.
[24:46] 그 다음 환경 변수같은
[24:48] 설정들을 불러올 텐데
[24:49] 이것들은 실행 전에 모두 설정할 수 있습니다.
[24:51] 예시를 바탕으로
[24:53] 자신만의 env 파일을 만드시고
[24:56] 로컬 LLM으로 Llama를 쓸지
[24:58] OpenAI를 사용할지에 따라
[25:00] 설정하시면 됩니다.
[25:02] 그리고 Supabase도 연결하고
[25:04] 판틱 AI에 내장된 로깅 모니터링을 위한
[25:07] Logfire는 지금은 사용하지 않을 겁니다.
[25:09] 나중에 아콘을 위해
[25:11] 설정하도록 하죠.
[25:13] 그리고 환경 변수들을 불러올 건데
[25:15] base URL이 있어서
[25:17] OpenAI나 Ollama 중 어떤 것을
[25:19] 사용할지 설정할 수 있습니다.
[25:21] OpenAI나 Ollama를 통해 실행할지 설정할 수 있죠.
[25:24] 또는 OpenRouter를 사용할 수 있고, 그 다음으로 LLM API 키가 필요합니다.
[25:26] API 키는 필수입니다.
[25:28] 물론 Ollama를 제외하고 말이죠.
[25:30] Ollama의 경우에는 API 키가 필요 없습니다.
[25:32] 로컬 머신에서 완전히 독립적으로 실행되기 때문이죠.
[25:34] 그리고 우리는 Ollama 실행 여부를 결정해야 합니다.
[25:36] 이는 base URL에 localhost가 포함되어 있는지를 기준으로 합니다.
[25:39] 제가 이렇게 하는 이유는 Pydantic AI에서
[25:42] Ollama가 다른 프로바이더들처럼
[25:45] 스트리밍을 지원하지 않기 때문입니다.
[25:47] 정확한 이유는 모르겠지만
[25:48] Pydantic AI의 버그라고 생각하며, 빨리 수정되었으면 합니다.
[25:51] 현재는 Ollama를 사용할 때
[25:53] LLM의 전체 출력을 기다려야만
[25:55] 화면에 표시할 수 있습니다.
[25:58] 실시간으로 글자가 타이핑되는 것처럼
[25:59] 출력되는 것이 아니라
[26:01] 한 번에 전체가 출력됩니다.
[26:04] 따라서 약간의 차이가 있을 것입니다.
[26:05] Pydantic AI 에이전트를 호출하는 방식에서
[26:07] Ollama 사용 여부에 따라 달라지죠.
[26:09] 다음으로 우리가 해야 할 것은
[26:12] Reasoner 에이전트를 정의하는 것입니다.
[26:15] 이것이 우리의 첫 번째 Pydantic AI 에이전트이며
[26:17] 워크플로우의 첫 번째 노드를 관리하는 역할을 합니다.
[26:20] 이 워크플로우에서
[26:22] 우리가 구축하는 AI 에이전트의
[26:24] 범위를 실제로 생성하는 것이죠.
[26:26] OpenAI 모델을 사용할 것이지만
[26:29] base URL을 오버라이드하여
[26:30] 로컬 LLM을 사용할지 여부를 결정할 수 있습니다.
[26:33] API 키도 마찬가지이고, 모델은
[26:35] 환경 변수에서 가져옵니다.
[26:37] 지정되지 않은 경우
[26:38] 기본값으로 O3-mini를 사용합니다.
[26:41] 하지만 직접 만든 Ollama 모델을 설정할 수도 있죠.
[26:43] 제가 만든 이 모델처럼 말이에요.
[26:45] 더 큰 컨텍스트 길이를 가지고 있어서
[26:47] 문제없이 작동합니다.
[26:49] 여기서 Reasoner 모델을 설정하고
[26:51] 실제 Pydantic AI 에이전트를 생성합니다.
[26:54] 시스템 프롬프트와 함께요.
[26:55] 매우 간단하게 유지하면서
[26:57] 이제 라우터 에이전트를 만들어야 합니다.
[27:00] 이 에이전트는 코더 에이전트와
[27:02] 동일한 LLM을 사용할 것입니다.
[27:04] 예를 들어 GPT-4, Mini,
[27:06] Qwen-2.5-instruct 등이 될 수 있죠.
[27:10] 이 에이전트가 필요한 이유는
[27:12] 이 루프 내에서 언제
[27:14] 대화를 종료하고 빠져나갈지
[27:16] 결정해야 하기 때문입니다.
[27:18] 라우터는 최신 사용자 요청을 받아
[27:20] 에이전트가 잘 작동하는지
[27:21] 판단하고 대화를 계속할지
[27:24] 아니면 다른 루프로 돌아가
[27:26] 코더 에이전트로 돌아갈지를 결정합니다.
[27:28] 이것이 이 에이전트의 역할이며
[27:30] 이 노드도 나중에 구축할 것입니다.
[27:32] 그리고 마지막으로
[27:34] 대화가 종료되면 마지막 에이전트가 있습니다.
[27:37] 이 에이전트의 유일한 작업은
[27:39] 대화를 요약하고 에이전트의 코드를 제공하며
[27:41] 실행 지침도 함께 제공하는 것입니다.
[27:43] 사용자가 대화 끝부분에서
[27:45] 이 명령들을 복사하여
[27:47] 자신의 컴퓨터에서
[27:49] 에이전트를 실행할 수 있도록 하는 것이죠.
[27:51] 이것이 모든 에이전트에 대한 설명이고
[27:53] 이제 이 모든 Pydantic AI에 대한
[27:55] 의존성을 정의해야 합니다.
[27:58] 의존성 설정을 진행하겠습니다.
[28:01] 자, 이제 우리의 AI 에이전트를 위한 의존성을 설정해볼 텐데요.
[28:03] RAG를 위한 임베딩에 필요한 OpenAI 클라이언트와
[28:05] Supabase 데이터베이스에서 RAG를 실행하기 위한
[28:07] Supabase 클라이언트가 필요합니다.
[28:10] LangGraph에서 가장 먼저 해야 할 일은
[28:12] 그래프를 정의할 때마다 해야 하는 것인데요,
[28:15] 바로 노드들을 정의하고 연결하기 전에
[28:18] 그래프의 상태를
[28:19] 관리해야 합니다.
[28:21] 실제로 한번 보여드리겠습니다.
[28:24] 여기 LangGraph UI에서
[28:26] 볼 수 있는 모든 항목들은
[28:28] 그래프 전체 실행 과정에서
[28:30] 추적해야 하는 정보들입니다.
[28:33] 예를 들어 메시지의 경우,
[28:35] 어떤 노드에 있든 상관없이
[28:38] 전체 대화에서
[28:39] 필요한 더 글로벌한 상태가 필요합니다.
[28:42] Reasoner가 생성한 스코프처럼
[28:45] 전체 대화에서 중요한
[28:47] 정보들을 추적해야 합니다.
[28:49] 이 정보들은 어떤 노드에서든
[28:51] 사용할 수 있어야 하고,
[28:54] 메시지 히스토리는
[28:55] 이 노드를 제외한
[28:56] 모든 노드에서 사용됩니다.
[28:58] 이 모든 것이 그래프의
[29:00] 전역 상태로 정의됩니다.
[29:02] 그래프의 특정 실행에서는,
[29:05] 예를 들어 단일 AI 에이전트를 생성할 때
[29:08] 이러한 요소들이 각 실행마다
[29:10] 개별적으로 설정됩니다.
[29:14] 대화 ID나
[29:15] 스레드 ID를 LangGraph에 전달하면
[29:18] 각각의 대화 ID에 대해
[29:20] 독립적으로 상태를 관리합니다.
[29:22] 따라서 그래프의 여러 실행을
[29:25] 동시에 수행할 수 있으며
[29:27] 각각 독립적인 상태를 가지게 됩니다.
[29:29] 이렇게 함으로써
[29:30] 여러 대화를
[29:32] 동시에 처리할 수 있습니다.
[29:34] 자, 이제 상태 설정이 끝났으니
[29:37] 첫 번째 노드를 정의해보겠습니다.
[29:39] Reasoner로 스코프를 정의하는 것이 첫 단계입니다.
[29:42] 여기 이 첫 번째 부분에서
[29:44] 우리가 이미 설정한 Reasoner 에이전트를
[29:47] 사용하는 실제 노드를 만들고 있습니다.
[29:49] 이 부분은 꽤 간단한데요,
[29:51] 먼저 Pydantic AI 코더에서
[29:53] 제공하는 함수를 사용합니다.
[29:55] 잠깐 보여드리겠습니다.
[29:57] 여기
[29:58] 아래로 스크롤해서 보시면
[30:00] Supabase에 있는 모든 Pydantic AI
[30:03] 문서 페이지를 가져오는
[30:06] 함수가 있습니다.
[30:07] 그리고 나서 프롬프트를 정의할 건데,
[30:10] 여기에는 이 모든 문서 페이지가 포함됩니다.
[30:12] Reasoner 모델에게 우리가 원하는 것은
[30:15] AI 에이전트를 만들기 위해
[30:17] 필요한 모든 것을 설명하는 문서를 만드는 것입니다.
[30:20] 또한 모델에게
[30:22] 이 에이전트 생성과 관련된
[30:24] 몇 가지 문서 페이지를
[30:25] 선택하도록 합니다.
[30:27] 이것은 좀 기초적인 방법이고,
[30:30] Reasoner를 사용하는
[30:32] 더 나은 방법이 있을 수 있지만,
[30:34] 이 예제도 꽤 괜찮은 방법입니다.
[30:36] 이제 이 Reasoner를 활용하는 것은
[30:39] Pydantic AI를 사용하면 매우 간단한데요,
[30:41] 다음과 같이 하면 됩니다.
[30:43] Reasoner.do_run을 통해 scope를 가져오고
[30:45] 결과를 파일로 작성할 것입니다.
[30:47] 실행 후 결과를 볼 수 있도록 파일로 저장하겠습니다.
[30:50] 실행 후에 보여드리겠지만
[30:51] 결과는 대략 이런 식으로
[30:52] 나타날 것입니다. README 미리보기를
[30:54] 여기서 열어보도록 하겠습니다.
[30:56] 이것이 GPT-4 Mini가 실제로
[30:59] 생성한 scope입니다. 앞서
[31:01] 보여드린 Archon 버전 2의 예시에서
[31:03] 제가 Reasoner로 GPT-4 Mini를 사용했는데
[31:06] 이는 버전 1과의 공정한 비교를 위해서였습니다.
[31:09] GPT-3가 너무 강력하기 때문에 GPT-4 Mini가
[31:12] 버전 1과 비교하기에 훨씬 더 적절한
[31:15] Reasoner LM이라고 할 수 있습니다.
[31:17] V1과 비교할 때 말이죠. 어쨌든
[31:20] 여기 scope 문서가 있고
[31:22] 우리는 단순히 scope를 반환할 것입니다.
[31:25] LangGraph에서 전역 상태를 업데이트하려면
[31:27] 이 그래프 실행에서 추적하고 있는
[31:30] 전역 상태를 업데이트하기 위해
[31:31] 모든 노드의 끝에서 객체를 반환해야 합니다.
[31:34] 이 객체에는 업데이트하려는
[31:36] 특정 값에 매핑되는 키가 있어야 하고
[31:39] 실제로 업데이트하려는 값이
[31:41] 있어야 합니다. 그래서 업데이트하려는
[31:42] 실제 값이 필요합니다. 그래프를
[31:44] 처음 실행할 때는 시작점에 있고
[31:47] scope 값은 정의되지 않았거나
[31:50] 그래프를 시작할 때 지정한 값일 것입니다.
[31:52] 하지만 Reasoner로 scope를 정의하면
[31:54] 이 상태가 실제로 업데이트됩니다.
[31:57] Reasoner가 정의한 이 상태는
[32:00] 영구적으로 유지될 것입니다.
[32:02] 그래프의 다른 노드에서 변경하지 않는 한
[32:04] Reasoner가 정의한 이 값이 유지됩니다.
[32:07] 이것이 상태를 업데이트하는 방법이고
[32:08] 이 값은 계속 유지됩니다.
[32:10] 이제 이 scope를 다른 프롬프트의
[32:11] 입력값으로 사용할 수 있습니다.
[32:14] 예를 들어 다른 노드에서
[32:16] 실제로 이렇게 할 것입니다.
[32:18] 잠시 후에 보여드리겠습니다.
[32:19] 이것이 우리의 첫 번째 노드입니다. 다음으로
[32:22] coder 에이전트를 위한 노드를 만들어야 합니다.
[32:24] 약속드린 대로 시각적으로
[32:26] 계속 보면서 진행하겠습니다.
[32:29] 이제 coder 에이전트를 만들고 있습니다.
[32:31] 이것이 이 워크플로우의 주요 담당자입니다.
[32:33] 대부분의 작업을 수행할 것이고
[32:35] 특히 사용자가 coder 에이전트에게
[32:37] 많은 피드백을 주고 싶을 때
[32:39] 이 에이전트가 중요합니다. 우리는
[32:41] V1에서 사용하던 주요 Pydantic AI
[32:43] Coder 에이전트를 사용할 것입니다.
[32:46] 하지만 이번에는 Reasoner가
[32:47] scope에서 제공한 많은 추가 컨텍스트도
[32:50] 함께 제공됩니다. 우리는 여기서
[32:52] 의존성을 만들고 있는데
[32:55] Supabase 클라이언트와 OpenAI
[32:57] 클라이언트가 Archon V1처럼 있고
[32:59] 이제 세 번째 의존성이 있습니다.
[33:01] Reasoner가 생성한 scope를
[33:04] Pydantic AI coder 에이전트의
[33:07] 시스템 프롬프트에 동적으로 주입하고 싶기 때문에
[33:10] 이 세 번째 의존성을 추가했습니다.
[33:12] pydantic_ai_coder.py 파일은
[33:16] V1의 파일과 정확히 동일하지만
[33:18] 이 세 번째 의존성이 추가되었습니다.
[33:21] 시스템 프롬프트에 동적으로
[33:24] 내용을 주입하는 방법은
[33:26] 다음과 같습니다.
[33:28] Pydantic AI에서는 '@'를 사용하고
[33:31] 그 다음에 에이전트의 이름을 참조할 수 있습니다.
[33:33] @pydantic_ai_coder do_system_prompt와 같이 사용하고
[33:37] 도구들과 마찬가지로
[33:40] 관련 문서를 검색하는 도구가 있듯이
[33:42] Pydantic AI가 자동으로
[33:45] 함수에 매개변수로 전달하는 컨텍스트가 있습니다
[33:47] 이것은 동적 시스템 프롬프트 함수에도
[33:50] 똑같이 적용됩니다
[33:52] 따라서 컨텍스트에서 Reasoner의 출력을 참조하고
[33:54] 그것을 시스템 프롬프트에 추가할 수 있습니다
[33:57] 이 함수에서 반환하는 것은
[33:59] 우리가 여기 가지고 있는 기본 시스템 프롬프트에
[34:02] 추가됩니다
[34:04] 이것이 바로
[34:05] Reasoner가 출력하는 범위를 동적으로
[34:08] 코더 에이전트의 시스템 프롬프트에
[34:11] 추가할 수 있는 방법입니다
[34:13] 시스템 프롬프트에 추가하는 이유는
[34:15] 시스템 프롬프트가 바로
[34:17] 에이전트의 행동과 일반적인 규칙을 정의하는 곳이고
[34:20] 우리가 만들고 있는 범위가 더 포괄적이기 때문입니다
[34:23] 우리가 만들고 있는 범위는
[34:24] 대화 기록 어딘가보다는
[34:27] 시스템 프롬프트에
[34:28] 포함되어야 합니다
[34:29] 이해가 되셨길 바랍니다
[34:31] Pydantic AI 문서에서
[34:33] 동적 시스템 프롬프트에 대해
[34:35] 더 자세히 살펴보실 수 있습니다
[34:36] 이것이 바로 우리가
[34:38] Pydantic AI 에이전트의 세 번째 의존성으로
[34:41] 이것을 추가하는 이유입니다
[34:44] 그리고 현재 상태에 있는
[34:46] 모든 대화 기록을 가져올 것입니다
[34:49] 처음 실행할 때는
[34:51] 빈 리스트겠지만, 사용자로부터
[34:53] 피드백을 받으면서
[34:55] 이 메시지 상태가
[34:56] 시간이 지남에 따라 쌓이게 됩니다
[34:58] 이것을 어떻게 하는지도 곧 보여드리겠습니다
[35:00] 우리는 이것을 가져와서
[35:03] Pydantic AI의 model_messages 타입 어댑터를 사용하여
[35:05] Pydantic AI 에이전트에 실제로 전달할 수 있는
[35:08] 형식으로 변환합니다
[35:11] 이것은 매우 중요한 점인데
[35:13] 메시지의 상태를 저장하는 형식이
[35:16] Pydantic AI 에이전트에 실제로 필요한
[35:19] 형식과 다르기 때문에
[35:20] 약간의 변환 작업이 필요합니다
[35:23] 에이전트로부터 결과를 받을 때와
[35:26] 메시지 기록을 다시 가져와서
[35:28] 에이전트에 다시 전달할 때 모두
[35:31] 이런 변환이 필요합니다
[35:33] 이것이 어떻게 작동하는지도
[35:35] 곧 더 자세히 보여드리겠습니다
[35:37] 메시지 기록을 가져오고
[35:39] Ollama를 실행할 때는 실제로
[35:42] 인터페이스로 출력을 스트리밍할 수 없기 때문에
[35:44] writer라는 개념을 사용해야 합니다
[35:47] 이것은 우리가 원하는 어떤 함수에도
[35:50] LangGraph에서
[35:51] 자동으로 제공되는 것으로
[35:53] 우리는 단순히 에이전트를 호출합니다
[35:54] pydantic_ai_coder.run을 호출하고
[35:58] 현재 프롬프트로 사용자의 최신 메시지를 전달하고
[36:01] 의존성들을 전달하고
[36:03] 여기서 만든 메시지 기록도
[36:05] 함께 전달합니다
[36:07] 이렇게 에이전트를 호출하는데
[36:09] 참고로 상태에서 최신 사용자 메시지를
[36:11] 가져오는 방법은 그래프로
[36:14] 직접 전달됩니다
[36:16] 우리가 사용하는 사용자 인터페이스를 통해서
[36:19] 다시 한 번 명확하게 설명하자면
[36:21] 여기 제 그래프로 돌아가서 보면
[36:24] 그래프를 처음 실행할 때
[36:26] 최신 사용자 메시지가
[36:28] 우리가 전달하는 것입니다. 예를 들어 'hello'라고 하면
[36:31] 그것이 그래프를 통과하고
[36:32] 여기서 범위가 정의됩니다. 더 좋은 예를 들자면
[36:35] '날씨 에이전트를 만들어줘'라고 하면
[36:38] 이것이 사용자의 첫 메시지가 되고
[36:40] 이 범위가 정의되고
[36:42] 그 다음 코더 에이전트로 넘어갑니다
[36:45] 여기서 범위는
[36:47] Reasoner가 지정한 대로 정의되고
[36:49] 최신 사용자 메시지는
[36:50] 그래프를 시작할 때
[36:52] 우리가 지정한 것이 됩니다
[36:55] LangGraph에서는
[36:56] 빠르게 보여드리겠습니다
[36:58] Streamlit에서 LangGraph 그래프를 실행할 때
[37:02] 이 객체를 전달합니다
[37:05] 여기서 최신 사용자 메시지는
[37:06] Streamlit UI에 입력된 내용이 됩니다
[37:08] 그리고 이것을 여기 노드 내에서 활용합니다
[37:12] 상태 내에서 최신 사용자 메시지를 가져오는데
[37:15] 상태 내에서
[37:16] 최신 사용자 메시지를 가져오고
[37:18] 이것은 우리가 정의한
[37:19] 그래프의 전역 상태 중
[37:21] 하나입니다. 이렇게 사용자로부터
[37:24] 메시지를 받습니다. 인터페이스에 의존하여
[37:27] UI가 그래프 시작 시 이 값을 전달합니다
[37:31] 이해가 되셨길 바랍니다
[37:33] 그리고 나서
[37:34] 결과를 출력합니다. 여기서는 일종의
[37:37] 스트림을 모방하고 있는데
[37:39] Streamlit이 스트리밍을 예상할 수 있도록
[37:42] Ollama를 사용하지 않을 때를 대비해서입니다
[37:43] 하지만 우리는 Ollama와 함께
[37:46] Pydantic AI 스트리밍을 사용할 수 없어서
[37:48] 이는 작은 문제인데
[37:50] 고쳐지길 바랍니다
[37:52] 어쨌든 Ollama를 사용하지 않는다면
[37:54] run_stream 명령을 사용해서
[37:57] 출력을 스트리밍하고 청크를 하나씩 받아
[37:59] 프론트엔드에 실시간으로 전달할 수 있습니다
[38:01] 다시 말씀드리면, 최신 사용자 메시지 상태
[38:05] 의존성과
[38:07] 메시지 히스토리를 사용하고
[38:09] 청크를 비동기적으로 받으면서
[38:11] 프론트엔드에 작성합니다
[38:13] 이게 전부입니다
[38:16] 이제 Pydantic AI 코더의 결과를 얻었습니다
[38:18] 이 시점에서 우리는
[38:20] AI 에이전트의 첫 번째 버전이
[38:23] 이 노드에서 생성되었습니다
[38:26] 여기서
[38:28] 이 두 단계를 실행했고
[38:29] 이제 사용자로부터 피드백을 받을 시간입니다
[38:33] 대화를 계속 진행할지
[38:34] 아니면 에이전트를 더 개선할지
[38:37] 결정해야 합니다
[38:40] 먼저 우리가 받은
[38:42] 새로운 메시지들을 가져옵니다
[38:45] 이 대화에서 얻은
[38:47] 도구 호출을 포함한
[38:48] 모든 것이 매우 중요합니다
[38:50] RAG의 모든 결과를 포함하여
[38:52] 대화 기록에 추가할 수 있는
[38:54] 모든 것을 포함하여
[38:56] 에이전트가 그 맥락을 유지할 수 있도록 합니다
[38:58] 이것이 매우 중요하죠. 이것들을
[39:00] 메시지에 추가하면 메시지 상태에는
[39:03] 이전의 모든 메시지가 포함됩니다
[39:06] 사용자의 프롬프트와 새로운 메시지들,
[39:08] 그리고 도구 호출 등도 포함됩니다.
[39:10] 이것이 우리가
[39:11] 시간에 따라 대화 기록을 쌓아가는 방식입니다.
[39:14] 이제 다음으로 우리가 하고 싶은 것은
[39:16] 사람이 개입하는 인터럽트를 추가하는 것입니다.
[39:19] 이제 우리의 스트림릿 인터페이스나
[39:21] 우리가 사용하고 있는 어떤 인터페이스로 돌아갈 시간입니다.
[39:24] 우리가 사용하고 있는 인터페이스에서
[39:27] 사용자로부터 다음 메시지를 받아야 합니다.
[39:29] 대화를 처리하는 다른 방법으로는
[39:31] 그래프를 종료한 다음
[39:33] 사용자의 다음 메시지가 들어올 때
[39:35] 완전히 새로 시작하는 방법이 있습니다.
[39:37] 저는 사람이 개입하는 방식을
[39:39] 보여드리기 위해 이렇게 설정했습니다.
[39:41] 기본적으로 우리가 할 것은
[39:42] LangGraph의 인터럽트라는 개념을 사용하는 것입니다.
[39:45] 이것이 본질적으로
[39:46] 사람이 개입하는 방식을 구현하는 방법입니다.
[39:49] 이 인터럽트와 이 객체를 통해
[39:51] 프론트엔드로 특정 값들을 전달할 수 있습니다.
[39:53] 예를 들어 에이전트가 특정 종류의
[39:55] 피드백을 요청할 때 사용할 수 있죠.
[39:57] 프론트엔드에 표시하고 싶은 내용을
[39:59] 여기 객체에 추가하면 됩니다.
[40:01] 이 경우에는 실제로
[40:02] 추가로 표시할 내용이 없어서
[40:05] 빈 괄호만 있습니다. 그래서
[40:07] 프론트엔드에서는 기본적으로
[40:08] 사용자가 메시지를 입력할 시간이라고
[40:10] 표시될 것입니다. 사용자들은
[40:12] 원하는 내용을 입력하고, 저는
[40:13] 최신 사용자 메시지를
[40:16] 전달받은 값으로 설정합니다.
[40:17] 그래프를 다시 호출할 때
[40:20] 사람이 개입하는 인터럽트 이후에
[40:22] 여기 제 스트림릿 코드를 보시면
[40:25] 대화를 시작할 때는
[40:27] 이런 방식으로 그래프를 호출하지만
[40:31] 대화가 계속되는 경우에는
[40:33] 이 명령어를 사용합니다.
[40:36] 여기서 이 내러티브로
[40:38] 사용자 입력 값으로 재개하고 있습니다.
[40:40] 너무 기술적인 설명은
[40:41] 하지 않겠지만,
[40:43] 기본적으로 이 명령어를 사용하는 것이
[40:45] 현재 실행 지점에서 그래프를 재개하는 방법입니다.
[40:48] 여기서 resume에 전달하는 값이
[40:50] 실제 값으로 주어지고,
[40:53] 그리고 우리는 이 객체를 반환합니다.
[40:55] 왜냐하면 이제 우리는
[40:57] 사용자 메시지 상태를
[40:59] 인터럽트 때 입력한 내용으로 업데이트하고 있기 때문입니다.
[41:01] 이해가 되셨길 바랍니다. 이것이 바로 이 노드입니다.
[41:04] 이제 우리는 코더 에이전트로
[41:06] 실행을 재개할 것이고
[41:08] 이 코드의 마지막에서 이 모든
[41:10] 다양한 노드들과
[41:12] 그들의 연결을 어떻게 설정하는지 보여드리겠습니다.
[41:15] 하지만 먼저 이 모든 노드들의
[41:17] 정의를 마무리합시다.
[41:19] 음, 다음으로 정의해야 할 것은
[41:21] 우리의 라우터입니다.
[41:23] 이것은 사용자가 에이전트가 잘했다고 판단하여
[41:26] 대화를 종료할지,
[41:28] 아니면 코더 에이전트로
[41:30] 돌아가야 할지를 결정하는
[41:32] 에이전트입니다.
[41:36] 이것이 그를 위한 제 프롬프트입니다.
[41:38] 우리가 방금 설정한 사용자의 최신 메시지를 바탕으로
[41:40] 대화를 종료할지 아니면 계속할지
[41:42] 결정하게 됩니다.
[41:44] 계속할지 여부를 확인할 것이고, 구조화된 출력을 사용할 수도 있습니다.
[41:46] 더 나은 방법이 분명히 있지만, 지금 이 방식도 잘 작동하고 있어서 문제가 없었습니다.
[41:50] 이 프롬프트로 라우터 에이전트를 실행할 것이고, 다음 동작은
[41:53] 대화 종료나 코더 에이전트 중 하나가 될 것입니다. 대화 종료인 경우
[42:00] 그래프의 마지막 노드로 이동하고, 그렇지 않으면 다시 되돌아갈 것입니다.
[42:06] LangGraph에서 라우터 노드를 사용할 때는 선택 가능한 노드들 중에서
[42:12] 이동하고자 하는 노드의 이름만 반환하면 됩니다.
[42:16] 이 파일 마지막에서 노드 간의 연결을 정의할 때 자세히 살펴보겠습니다.
[42:25] 자, 이제 마지막 노드입니다. 이것은 대화를 종료하기 위한 노드입니다.
[42:29] 다른 코더 에이전트 노드처럼, Pydantic AI에 전달할 대화 기록을 생성합니다.
[42:35] AMA인 경우 종료 대화 에이전트를 호출하고, 여기서는 스트림을 모의 실행하며 동기적으로 실행됩니다.
[42:45] 다른 모든 설정은 동일한 방식으로 되어 있고, 그 다음에
[42:53] 종료 대화 에이전트에서 run_stream을 호출할 것입니다. 시스템 프롬프트에서는
[42:57] 종료 대화 에이전트에게 대화를 요약하고, 에이전트의 최종 코드와 실행 지침을 제공하도록 지시합니다.
[43:04] 이 마지막 메시지의 모든 청크를 프론트엔드로 스트리밍할 것입니다.
[43:11] 상태의 메시지들을 업데이트하여 대화 기록이 갱신되도록 합니다.
[43:15] 코더 에이전트와 매우 유사한 설정이며, 여기서는 메시지 상태에 JSON을 사용합니다.
[43:23] 이것을 우리가 실제로 저장하고자 하는 형식으로 변환하는데, 바이너리 JSON입니다.
[43:28] Pydantic AI가 이런 방식을 사용하는 게 좀 이상하지만, Pydantic AI 에이전트를 호출해서
[43:34] 새로운 메시지를 가져올 때 바이너리 JSON으로 변환되어 이 메시지 상태에 저장됩니다.
[43:42] 그리고 이것을 다시 Pydantic AI에 전달하기 위해 모델 메시지 어댑터를 사용하여 변환할 때
[43:49] 바이너리 JSON에서 Pydantic AI가 메시지를 표현하는데 사용하는 객체 형식으로 변환됩니다.
[43:57] 이제 우리가 정의한 그래프의 상태를 기반으로 이 빌더를 생성할 수 있습니다.
[44:04] 모든 노드를 추가할 수 있습니다. Reasoner LLM이 있는 범위 정의자,
[44:09] 코더 에이전트, 메시지를 가져오기 위한 인터럽트가 있는 노드,
[44:14] 그리고 마지막으로 대화 종료 에이전트가 있습니다. 이제 엣지를 설정할 차례입니다.
[44:18] 지금까지 정의한 것은 개별 노드들이었고, 이제 이들이 어떻게 연결되는지 정의해야 합니다.
[44:24] 먼저 연결 방법을 설명하자면
[44:27] 그래프의 시작점은
[44:29] 바로 Reasoner 노드와 연결됩니다
[44:32] 그 다음 Reasoner를
[44:33] 코더 에이전트와 연결하는데, 이 시점에서는
[44:36] 별도의 라우팅 없이 직접 연결됩니다
[44:38] Reasoner에서 바로
[44:40] 코딩 에이전트로 이동하고, 코딩
[44:42] 에이전트는 사용자로부터
[44:44] 다음 메시지를 받는 노드로 이동합니다
[44:47] 여기서부터 조건부 엣지가
[44:49] 시작되는데, 이제 우리는
[44:51] 결정을 내려야 하는
[44:52] 시점에 도달했습니다. 이 파란색 노드는
[44:56] 이 파란색 화살표나
[44:58] 저 파란색 화살표를 따를 수 있고
[44:59] 우리는 이를 결정해야 합니다
[45:00] 이때 사용하는 것이 route_user_message
[45:03] 함수입니다. 바로 여기 있는
[45:05] 다음 노드의 이름을 반환하는
[45:07] 함수죠. 만약
[45:11] 'coder_agent'를 반환하면
[45:13] 이 노드로 이동하고, 그렇지 않고
[45:16] 'finish_conversation'을 반환하면
[45:17] 대화 종료로 이동합니다
[45:20] LangGraph에서 이러한
[45:22] 조건부 엣지의 작동 방식을 이해하기 쉽죠
[45:24] 이것이 바로 LangGraph가
[45:25] 도움을 주는 부분입니다
[45:27] 이런 모든 Pydantic AI 에이전트를 정의하고
[45:30] 연결하는 것이 LangGraph 같은
[45:32] 도구 없이는 쉽지 않았을 겁니다
[45:34] LangGraph는 모든 것을 조율하고
[45:37] 간단한 라우팅 함수를 제공하며
[45:38] 전역 상태를 정의하고
[45:40] 매우 쉽게 업데이트할 수 있죠
[45:42] LangGraph 같은 도구를 사용하는 것이
[45:44] 얼마나 강력한지, 그리고
[45:46] Pydantic AI로 이런 개별 에이전트를
[45:48] 쉽게 만들 수 있다는 것이
[45:49] 이해되셨길 바랍니다
[45:52] 이 두 도구를 함께 사용하는
[45:54] 파워를 보셨을 텐데요
[45:55] 마지막 엣지로 대화 종료는
[45:57] 끝 노드로 이동하고, 여기에
[46:00] 메모리를 추가하여 채팅
[46:02] 내역을 유지할 수 있게 하고
[46:04] 그래프를 컴파일하면 끝입니다
[46:06] 정말 간단하죠. 참고로 이것은
[46:08] 모든 상태를 메모리에 저장하는 방식을 사용하고 있는데
[46:11] 그래프의 각 실행에 대한 상태를
[46:14] 저장할 때는 SQLite나
[46:17] PostgreSQL 메모리 세이버를 사용하는 것을
[46:19] 추천합니다. LangGraph 문서에서
[46:21] 확인하실 수 있으며
[46:23] Archon의 향후 버전에 추가할 예정이지만
[46:25] 지금은 단순하게 유지하기 위해
[46:27] 모든 것을 메모리에서 실행합니다
[46:29] 제가 파이썬 스크립트를 실행하면
[46:31] 터미널에서 실행되고 있는데
[46:33] RAM에 모든 것을 저장하게 됩니다
[46:34] 채팅 기록이나
[46:36] 범위, 그리고
[46:38] 여기 상태에 정의된
[46:39] 모든 것들이 저장되죠. 이것으로
[46:41] 그래프 설명을 마치겠습니다
[46:44] 꽤 시간이 걸렸네요
[46:46] 20분 정도 설명했는데
[46:47] LangGraph에 대해 정말 포괄적인
[46:50] 개요를 제공하고 싶었습니다
[46:53] 혹시 질문이 있다면
[46:54] 제가 설명한 내용 중에서
[46:55] 이해가 잘 안 되는 부분이나
[46:57] 제가 설명이 부족했거나 시각적 자료가
[47:00] 작동 방식을 이해하는 데 충분하지 않았다면
[47:01] 댓글로 알려주시면
[47:03] 이해하실 수 있도록 도와드리겠습니다.
[47:05] 제가 충분히 깊이 있게 다루지 못한 부분이 있다면
[47:07] 앞으로도 제 채널에서는 계속해서
[47:10] LangGraph와 Pydantic AI에 대해
[47:12] 더 깊이 있게 다룰 예정입니다.
[47:14] 이 도구들로 정말 놀라운 것들을
[47:16] 만들 수 있기 때문이죠.
[47:17] 여기서는 Streamlit 인터페이스에 대해
[47:19] 자세히 설명하지는 않겠지만
[47:21] 보시다시피 전체 코드가 115줄 정도밖에 되지 않습니다.
[47:23] 전체 채팅 인터페이스를 설정하는 데
[47:25] LangGraph 구현과 함께 사용하는 것이 매우 쉽습니다.
[47:28] 그리고 호출하는 방법도 매우 간단한데
[47:31] 여기서 보시는 것처럼
[47:32] 이미 조금 설명했지만
[47:33] 이 stream 명령어만 실행하면 됩니다.
[47:35] 에이전트 플로우에서 제가 만든 것은
[47:38] 맨 아래에 있는 이 부분인데
[47:40] 이것을 Streamlit UI에서 임포트해서
[47:43] 여기서 사용하고 있습니다.
[47:45] 다시 아래로 내려가서 보면
[47:47] stream을 호출할 때 최신 사용자 메시지를 전달하는데
[47:49] 이는 human-in-the-loop를 계속할 때나
[47:51] 또는 대화를 처음 시작할 때
[47:52] 모두 동일하게 적용됩니다.
[47:55] 그리고 이 커스텀 writer를 얻는 방법은
[47:57] 마지막으로 다루고 싶은 부분인데
[47:58] 보시면 writer가 있습니다.
[48:00] 이것은 coder agent와 finish_conversation에
[48:03] 전달되는데
[48:06] 이는 LangGraph에 stream 모드를
[48:09] custom으로 설정하면 자동으로 주입됩니다.
[48:12] 이런 세세한 부분들을 파악하는 데
[48:15] 시간이 좀 걸렸는데
[48:18] 제가 겪었던 어려움을 여러분은
[48:20] 겪지 않으셨으면 해서
[48:21] 이렇게 자세히 설명드립니다.
[48:23] 제가 겪었던 시행착오를 통해
[48:25] 작은 문제들을 해결하면서
[48:27] LangGraph와 Pydantic AI가
[48:28] 실제로 잘 작동하도록 만들었습니다.
[48:30] 이 내용이 도움이 되었기를 바랍니다.
[48:32] 자, 이제 여기까지 했고
[48:34] 이제 빠른 테스트를 해보면서
[48:35] 재미있게 진행해보겠습니다.
[48:36] 이제 구현이 완료되었으니
[48:37] 여기까지 따라오신 여러분, 축하드립니다!
[48:40] 이것은 간단한 구현은 아니었지만
[48:42] 얼마나 강력한 도구인지
[48:44] 이해하셨기를 바랍니다.
[48:46] 또한 설명을 명확하게 했기를 바라며
[48:48] 그래프 시각화도
[48:49] 도움이 되었길 바랍니다.
[48:51] 이제 실제로 이것을 가지고
[48:53] 재미있게 실험해보겠습니다.
[48:54] V1과 비교할 때 이미 시도해봤지만
[48:56] 이번에는 좀 더 재미있게 해보죠.
[48:58] 이제 전체 기능을 사용할 건데
[49:00] Reasoner로는 O3-mini를 사용하고
[49:02] 메인 코드 에이전트로는 GPT-4를 사용하겠습니다.
[49:05] 여기 있는 예제를 구현해볼 건데
[49:07] 간단한 웹 검색 에이전트입니다.
[49:09] 어떻게 작동하는지 보죠.
[49:11] 터미널에서 실시간으로
[49:13] 결과가 들어오는 것을 볼 수 있습니다.
[49:15] 먼저 O3-mini가 코딩 에이전트를 위한
[49:16] 범위 문서와 컨텍스트를 생성합니다.
[49:19] O3-mini는 추론 모델이라 속도가 빠르진 않지만
[49:22] Reasoner 모델로서는
[49:24] 꽤 빠른 편이네요.
[49:25] 자, 이제 우리의 Pydantic AI 코더 에이전트로
[49:27] 넘어가고 있습니다. 이 에이전트는 RAG를
[49:30] 수행하며 문서 페이지를 살펴보고
[49:32] 추가 컨텍스트를 위해 Pydantic AI
[49:34] 문서에서 페이지들을 가져오고 있습니다.
[49:36] 보세요, 정말 멋집니다.
[49:39] 좋습니다. 여기 의존성들이 있네요.
[49:42] HTTP 클라이언트와 Brave API 키가 있고
[49:44] OpenAI GPT-4를 모델로 사용하고 있습니다.
[49:47] 시스템 프롬프트가 있고
[49:49] 의존성들을 올바르게 정의하고 있습니다.
[49:51] 정말 잘 되고 있네요.
[49:53] 그리고 데코레이터가 있는 도구도 있습니다.
[49:55] 잘 작동하고 있고, Pydantic AI
[49:57] 컨텍스트에서 Brave API를 가져왔네요.
[50:00] 정말 놀랍습니다.
[50:03] 도구 구현이 완벽하고 메인 함수도 좋아 보입니다.
[50:05] 그리고 tools와 prompts에는
[50:07] 아무것도 필요하지 않다고 알려주네요.
[50:09] 이미 여기에 모두 정의되어 있기 때문입니다.
[50:10] 예제 파일을 보면
[50:13] OpenAI API 키가 빠진 것 같네요.
[50:15] 아마도 필요할 것 같은데
[50:18] 적어도 Brave API 키는 있네요.
[50:20] 완벽하진 않습니다.
[50:21] 우리가 왜 Archon의 향후 버전이
[50:23] 필요한지 확실히 알 수 있죠.
[50:26] 하지만 Archon V1과 비교하면 정말 좋아 보입니다.
[50:30] GPT나 Cursor 또는 다른 AI 코딩
[50:31] 어시스턴트로 이런 에이전트를 만드는 것보다
[50:34] 이건 정말 뛰어난 성과를 보여줍니다.
[50:36] 이런 것들을 만들 수 있다는 게
[50:38] 정말 멋지네요.
[50:40] 자, 이제 Pydantic AI와
[50:42] LangGraph, Archon에 대한 심층 분석을 마무리하겠습니다.
[50:44] 그리고 제가 Archon에 대한 큰 계획이 있다는 걸 믿으세요.
[50:48] 이것을 혁신적인 오픈소스
[50:50] 에이전트로 발전시켜서
[50:52] 에이전트를 만드는 방식을 완전히 바꾸고
[50:54] 이러한 코딩 프레임워크를
[50:56] 비개발자들도 접근할 수 있게 만들고 싶습니다.
[50:58] 앞으로도 계속 지켜봐 주시고
[51:01] Archon에 관심이 있거나
[51:03] Pydantic AI와 LangGraph를 사용하는 데
[51:05] 관심이 있다면 향후 콘텐츠도 시청해 주세요.
[51:07] 저는 Archon을 계속 사용하면서
[51:08] 이 모든 것을 명확하고 간단하게 가르치는
[51:11] 방법으로 활용할 예정입니다.
[51:13] 이 콘텐츠가 도움이 되었고
[51:15] Pydantic AI와 LangGraph의 향후 발전이
[51:16] 기대된다면
[51:18] 좋아요와 구독 부탁드립니다.
[51:20] 다음 영상에서 만나뵙겠습니다.
[51:22] 감사합니다.