DEV Community: otololism

RAG201 의 개념과 필요성

otololism — Sat, 25 Apr 2026 06:09:39 +0000

1️⃣ 섹션 1. 교재 다운로드~섹션 4. Langchain 프레임워크 소개 수강

RAG201 의 개념과 필요성

개요

LLM이 거짓말을 하는 이유?

GAG란?

개요

RAG(Retrieval-Augmented Generation, 검색 증강 생성) 서비스는 대규모 언어 모델(LLM)의 hallucination(환각 현상)을 최소화하며 외부 지식 베이스를 실시간 검색해 컨텍스트를 증강하는 AI 아키텍처이다.

필요성

기본 나이브 서비스 방식으로는 충분하지 않기 때문에 다양한 방법으로 설계한다.

그럼 LLM 언어모델이 무엇인지 알아보자.

LLM의 이해

초기 인코더+디코더의 구조를 활용하여 번역소프트웨어엔진을 개발하던 중 디코더 부분 (다음 단어가 나올 수 있는 확률의 프로세싱)만가지고 여러 레이어를 쌓아 Text Prediction + Tack Classifier으로 GPT란 소프트웨어를 개발 하였음.

학습량을 늟리고 디코더의 새수를 개속적으로 늟기게 되면서 메모리의 증가로 GPT의 모델이 발전함.

초기에는 인코더–디코더 구조의 트랜스포머를 이용하여 기계번역 엔진을 개발했다. 인코더는 입력 문장을 의미 공간의 표현(continuous representation)으로 압축하고, 디코더는 이 표현을 참고하면서 번역 결과 문장을 한 토큰씩 생성한다.

이후 연구에서는 이 구조 중 디코더가 담당하던 “이전 단어들을 기반으로 다음 단어의 확률 분포를 예측하는” 언어 모델링 부분에 주목했다. 이 디코더만을 여러 층으로 깊게 쌓은 디코더 전용(Decoder-only) 트랜스포머 구조를 사용해, 텍스트 생성(Text Prediction)과 텍스트 분류(Task Classification)을 수행하는 GPT(Generative Pre-trained Transformer) 계열 모델이 개발되었다.

GPT는 대규모 코퍼스에 대해, 주어진 토큰 시퀀스가 올 때 다음 토큰의 조건부 확률을 최대화하도록 사전학습(pre-training)된 언어 모델이다. 이렇게 학습된 표현을 기반으로 프롬프트 설계나 간단한 미세조정(fine-tuning)만으로 번역·요약·질의응답·분류 등 다양한 다운스트림 태스크에 활용할 수 있다.

모델의 성능은 크게 두 방향으로 확장되었다. 하나는 학습 데이터의 양과 학습 스텝을 증가시키는 것이고, 다른 하나는 디코더 블록(레이어)의 개수, 임베딩 차원, 어텐션 헤드 수 등을 늘려 파라미터 수를 키우는 것이다. 이러한 스케일 업은 메모리 사용량과 연산량을 크게 증가시키지만, 손실 감소 및 다양한 벤치마크에서의 성능 향상으로 이어지며 GPT-1, GPT-2, GPT-3, GPT-4 등 대형 언어 모델로 발전하는 데 핵심적인 역할을 했다.

LLM의 한계

개요

GPT3의 버젼 업에서 GPT4로 넘어가지 않고 3.5의 이름으로 버젼 이름을 사용한 이유로 볼 수 있다.

GPT-3.5라는 이름은 GPT-3와 GPT-4 사이의 중간 세대(Intermediate iteration)를 나타내는 버전명이다.

GPT-3와 동일하게 디코더 전용 트랜스포머 구조와 다음 토큰 예측 목표를 유지한다.
다만 모델 크기, 학습 데이터, 미세 튜닝 방식(RLHF 기반 정렬 등)이 개선되면서 성능이 향상된 “개선형 GPT-3”에 가깝다.
“GPT-3에서 전혀 새로운 개념이 추가되지 않았다”라고 단정하기보다는, “기존 아키텍처와 학습 목표를 유지한 채, 사람 선호도에 맞게 정렬하고 성능을 튜닝한 강화 버전”이라고 표현하는 것이 더 정확하다.
GPT-3.5 계열(ChatGPT 초기 모델 포함)은 대규모 감독 학습 + 강화학습(RLHF)으로 인간 선호를 반영한 응답을 내도록 추가 학습된 것이 핵심 차별점이다.
여전히 모델의 내부는 “조건부 확률
P(next token ∣ previous tokens)을 최대화하도록 학습된 언어 모델”이라는 구조를 유지한다.

확각현상 : 학습이 없는 자료에도 강제 답변을 요구에 의해서 이전 대이터를 활용한 답변
기억불가: 사전학습에서 배운 것 외의 자료는 기억을 못함.
토큰제한: 입력값이 길어지면 계산량이 크게 증가하므로 모델별 토큰에 제한을 두게 됨.

RAG의 개념

LLM의 한계를 극복하기 위한 방법으로

RAG에서 증강(augmentation)은 검색된 정보를 AI에게 공부 자료처럼 제공하여 답변의 정확성을 높이는 단계이다.

간단한 비유

AI가 시험 문제에 책 지식만으로 대응할 때 잘못된 답을 만들어낼 수 있다. RAG는 그 순간 책에서 문제와 딱 맞는 페이지를 복사해 AI 책상에 놓아주는 과정이다. AI는 이 자료를 보고 정확한 답변을 생성한다.

설명

질문 → 책장 검색 → 관련 페이지 3장 추출(질문)
↓
AI 책상에 페이지 제공(증강) ← 증강 단계(힌트)
↓
AI가 자료 보고 답변 생성

RAG파이프라인 개요와 핵심 컴포턴트

데이터 인덱싱 과정
PDF, 워드, 파워포인트, 웹링크 같은 문서(Document) 를 먼저 작은 조각으로 나눈다(Chunk).

각 조각을 벡터 임베딩(Vector Embedding)으로 바꾼 뒤, 이 벡터들을 벡터 데이터베이스(Vector DB)에 저장해 둔다.

질의·검색·답변 생성 과정
사용자가 “현재 갤럭시 Z 시리즈의 최신 모델은 뭐야?” 같은 질문(Query) 을 입력한다.
이 질문도 벡터 임베딩으로 바꾼 뒤, 벡터 DB에서 비슷한 의미의 문서 조각들을 검색(Retrieval)하고 Top‑K 조각을 가져온다.

이렇게 찾은 관련 문서 조각들을 LLM에게 함께 넘겨, LLM이 이를 참고하여 최종 답변(Answer) 을 생성하는 흐름을 보여준다.

“자료 찾아서 똑똑하게 대답해 주는 챗봇(RAG)”만들기

RAG 기반 챗봇은 문서 내용을 미리 벡터로 인덱싱하여 벡터 DB에 저장해 두고, 질의 시 의미적으로 유사한 문서를 검색하여 이를 힌트로 포함한 프롬프트를 LLM에 제공함으로써 보다 정확한 답변을 생성하는 시스템이다.

1단계: 문서 불러오기 (Document Loader)

문서 로더는 PDF, 워드, PPT, 웹페이지 등 다양한 형태의 문서를 읽어 텍스트로 변환하는 역할을 한다.

오픈 소스
- LangChain Document Loaders: PDF, Word, HTML, Notion, Google Drive 등 수십 종의 로더 제공.
- Unstructured.io: PDF, 스캔 이미지, 슬라이드 등을 구조화된 텍스트로 변환하는 파이프라인.
상용/클라우드 API
- Microsoft Graph / Google Drive API: OneDrive, SharePoint, Google Drive에 저장된 문서를 불러올 때 사용.
- AWS Textract / Azure Form Recognizer: 스캔 문서·이미지(PDF, 스캔된 계약서 등)를 텍스트로 OCR 추출하는 서비스.

2단계: 문서 임베딩 (Embedding Model)

문서·질문을 의미 벡터로 바꾸는 단계이며, 검색 정확도에 직접적인 영향을 준다.

오픈 소스
- Sentence Transformers (all-MiniLM-L6-v2, all-mpnet-base-v2, paraphrase-multilingual-MiniLM-L12-v2 등): 파이썬 sentence-transformers 라이브러리로 사용, 로컬 RAG에서 가장 널리 쓰이는 계열.
- nomic-embed-text, gte-small/large 등: RAG 벤치마크에서 성능이 좋은 범용 임베딩 모델.
상용 API
- OpenAI Embeddings (text-embedding-3-small, text-embedding-3-large): 검색·클러스터링·추천 등 범용 용도로 가장 많이 사용되는 상용 임베딩 API.
- Cohere Embed API: 의미 검색·추천 시스템에 최적화된 상용 임베딩 서비스.
- (참고) Google Gemini, Voyage AI, Mistral 등도 각각 임베딩 API를 제공하며, 비용·언어지원·성능 기준으로 선택한다.

3단계: 벡터 DB 저장 및 검색 (Vector DB)

생성된 임베딩 벡터를 저장하고, 질문 임베딩과의 유사도(코사인, 내적 등)를 기준으로 Top‑K 문서를 검색하는 역할이다.

오픈 소스
- FAISS (Meta): CPU/GPU에서 대규모 벡터 검색을 지원하는 라이브러리로, 로컬 RAG에서 표준처럼 사용된다.
- Qdrant, Milvus, Weaviate: gRPC/REST API를 제공하는 오픈 소스 벡터 데이터베이스.
상용/매니지드 서비스
- Pinecone: 완전 관리형 벡터 DB 서비스로, OpenAI·LangChain과 연동 예제가 매우 많다.
- Azure AI Search / Elasticsearch + vector: 기존 검색 인프라에 벡터 검색 기능을 추가한 형태로 엔터프라이즈에서 자주 사용된다.

4단계: LLM 프롬프트 구성 및 답변 생성

검색된 유사 문장(힌트 문장)을 사용자 질문과 함께 하나의 프롬프트로 구성하여 LLM에 전달하고, LLM이 이를 바탕으로 최종 답변을 생성한다.

오픈 소스 LLM
- Llama 3 / Llama 2: 메타의 오픈 소스 LLM으로, 8B·70B 등 다양한 크기와 Chat/Instruction 튜닝 버전이 있어 RAG 백엔드로 많이 사용된다.
- Mistral / Mixtral, Qwen, Gemma: 다국어 지원·긴 컨텍스트·경량성을 강점으로 갖는 최신 오픈 소스 LLM들로, 로컬·온프렘 RAG에서 인기 있다.
OpenAI GPT 계열
- 대표 모델: GPT‑4.1, GPT‑4o, o3‑mini 등.
- 특징: 생태계·예제가 풍부하고, RAG용 프롬프트 패턴이 가장 많이 축적되어 있음.
Anthropic Claude 계열
- 대표 모델: Claude 3.5 Sonnet, Claude 3 Opus, Claude 3 Haiku 등.
- 특징: 최대 200K 이상 컨텍스트 윈도우를 지원하여 긴 문서 기반 RAG에 유리하고, 안전성·환각 감소에 초점을 둔 설계가 강점.
Google Gemini 계열
- 대표 모델: Gemini 1.5 Pro, Gemini 1.5 Flash 등.
- 특징: 텍스트·이미지·코드 등 멀티모달 입력을 지원하고, Vertex AI RAG Engine·File Search 도구를 통해 임베딩·벡터 검색·컨텍스트 주입까지 통합 제공.

전체 흐름 한 줄 정리

문서 로더·임베딩 모델·벡터 DB·LLM을 조합하여, 문서를 로드하고 → 임베딩으로 변환해 벡터 DB에 저장한 뒤 → 질문 임베딩으로 유사 문서를 검색하고 → 그 문맥을 포함한 프롬프트를 LLM에 전달하여 답변을 생성하는 구조가 RAG의 기본 파이프라인이며, 각 단계에서 위와 같은 오픈 소스 컴포넌트와 상용 API가 널리 활용된다.

RAG를 활용하는 기업과 이에 산악협력하는 벤쳐기업들

구분	이름	연구기관·Labs	설명 (20자 내)
금융	KB국민카드	스켈터랩스	이벤트 Q&AI RAG 챗봇skelterlabs+1
금융	신한투자증권	스켈터랩스	사내 RAG 챗봇 ‘챗프로’skelterlabs+1
금융	BC카드	내부 데이터팀	약관·리포트용 RAG 논의bcif.bccard
금융	다수 금융사	올거나이즈	금융 RAG 리더보드·PoCblog-ko.allganize+1
법률	로톡(로앤컴퍼니)	로앤굿·AI팀	AI 변호사 추천·검색aidev+1
법률	로앤굿(로앤봇)	내부 변호사·AI팀	RAG 기반 법률상담 챗봇aidev
법률	빅케이스GPT	법무법인·데이터팀	판결문 요약·유사판례techsuda+1
법률	한국 법률 RAG 챗봇 예제	GitHub law_chatbot	한국어 법률 RAG 예제github
공공	통계청	민간 AI 기업	통계 챗봇에 RAG 도입beyondpost
공공	법제처	민간 AI 컨소시엄	AI 법령 RAG 서비스lawtalknews+1
공공	K-water	그리드원	K‑water GPT 공공 RAGnaver
공공	국가기록원	솔트룩스	기록물 지능형 검색·RAGsaltlux
공공	공공기관 다수	안랩클라우드메이트	규정 관리 RAG 어시스턴트techinterviewblog
헬스케어	메이크봇H	국내 대형병원 다수	병원 예약·문의 RAG 챗봇asiae+1
헬스케어	메이크봇 HybridRAG	자체 연구랩	HybridRAG 프레임워크makebot+1
헬스케어	의료 RAG PoC들	대학병원·연구소	진단 보조·문서 RAG 실험seo.goover
범용	AIFRICA Gazelle RAG	AIFRICA Lab	폐쇄망용 Gazelle RAGaifrica
범용	Konan RAG‑X	Konan LLM Lab	기업용 RAG‑X 패키지konantech
범용	WISE iRAG V2	WISENUT R&D	검색 기반 iRAG 솔루션wisenut+1
범용	LUXIA A.RAG	솔트룩스 연구소	공공·엔터프라이즈 RAGsaltlux

Langchain 개념과 아키텍처

LangChain 개념

LangChain은 LLM을 단독으로 사용하는 대신, 여러 컴포넌트를 연결하여 실세계 애플리케이션을 구축한다. 핵심 아이디어는 '체인화'로, 입력에서 출력까지 순차적 또는 병렬적 처리를 지원한다. 예를 들어, 텍스트 입력 → 검색 → 요약 → 응답 과정을 자동화한다.

주요 아키텍처 컴포넌트

Models: LLM(예: GPT 시리즈) 또는 임베딩 모델을 추상화한 인터페이스.
Prompts: 입력 템플릿을 관리하며, 동적 변수 삽입을 지원.
Chains: 컴포넌트를 순차 연결하는 기본 단위(예: LLMChain).
Agents: 도구(검색, 계산기 등)를 동적으로 선택·실행하는 지능형 체인.
Memory: 대화 히스토리나 벡터 저장소를 통해 상태 유지.

동작 원리

입력 데이터를 프롬프트로 변환한 후 체인 내 모델에 전달하고, 출력은 다음 컴포넌트로 전달된다. 예: RetrievalQA 체인은 벡터 DB에서 관련 문서를 검색·회수한 후 LLM으로 답변 생성. 이는 모듈러 설계로 확장성과 디버깅을 용이하게 한다.

실무 예시

질의응답 시스템에서 LangChain은 문서 로더 → 임베딩 → 벡터 저장소 → 리트리버 → LLM 체인을 구성한다. 이는 RAG(Retrieval-Augmented Generation) 패턴의 표준 구현으로, 환각(hallucination) 감소와 정확도 향상을 이룬다.

LLM의 발전과 함께 중요해진 프롬프트 엔지니어링을 보조할 수 있다.

프롬프트 엔지니어링이란?

AI의 언어와 인간의 언어사이에 인간이 편하게 이해 할 수 있도록 목적에 맞는 답변을 해주는 문장을 만들어 주는 역활을 한다.

Langchain을 사용한 RAG구현 워크플로우

RAG(Retrieval-Augmented Generation) 시스템의 단계별 공정

RAG 시스템은 데이터를 저장 가능한 형태로 가공하는 인덱싱(Indexing) 과정과 사용자의 질문에 맞춰 최적의 답변을 도출하는 검색 및 생성(Retrieval & Generation) 과정으로 나뉜다.

1. 문서 로드 및 수집 (Document Loading)

시스템 구축의 첫 단계는 PDF, 워드, 웹페이지 등 다양한 형식의 원천 데이터를 확보하는 것이다. 이 단계에서는 외부 소스로부터 데이터를 가져와 시스템이 처리할 수 있는 문서 객체로 변환한다.

2. 텍스트 분할 (Text Splitting)

불러온 방대한 양의 문서를 효율적으로 처리하기 위해 '청크(Chunk)'라고 불리는 작은 단위로 세분화한다. 이는 정보의 탐색 속도를 높이고 인공지능이 한 번에 이해할 수 있는 적절한 정보량을 유지하기 위함이다.

3. 벡터 임베딩 (Vector Embedding)

분할된 텍스트 데이터는 임베딩 모델을 거쳐 수치화된 데이터인 '벡터(Vector)'로 변환된다. 이는 컴퓨터가 텍스트의 의미적 유사성을 계산할 수 있도록 기계어로 바꾸는 핵심 공정이다.

4. 벡터 데이터베이스 저장 (Vector Store)

수치화된 데이터는 검색 최적화 과정을 거쳐 벡터 데이터베이스(Vector Database)에 저장된다. 이 저장소는 사용자의 질문이 입력되었을 때 가장 연관성이 높은 데이터를 신속하게 찾아낼 수 있는 역할을 수행한다.

5. 검색 및 유사 문장 추출 (Retrieval)

사용자가 질문(Query)을 입력하면 해당 질문 역시 수치(벡터)로 변환된다. 이후 시스템은 데이터베이스 내에서 질문의 수치와 가장 유사한 정보를 담은 문장들을 선별하여 추출한다.

6. 답변 생성 (Generation)

최종적으로 대형언어모델(LLM)은 사용자의 질문과 시스템이 찾아낸 관련 정보를 결합한다. 모델은 제공된 힌트 문장들을 바탕으로 근거에 기반한 정확한 답변을 생성하여 사용자에게 전달한다.

## Langchain을 표현하는 언어, LCEL****

[LCEL로 기본 체인 구성하기]

import os
os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"

#필수 라이브러리 설치
!pip install --upgrade --quiet langchain openai langchain-core langchain-openai

rom langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

#프롬프트 템플릿 설정
prompt = ChatPromptTemplate.from_template("tell me a short joke about {topic}")

#LLM 호출
model = ChatOpenAI(model="gpt-4o-mini")

#출력 파서 설정
output_parser = StrOutputParser()

#LCEL로 프롬프트템플릿-LLM-출력 파서 연결하기
chain = prompt | model | output_parser

#invoke함수로 chain 실행하기
chain.invoke({"topic": "ice cream"})

**[Streaming 기능 추가를 더욱 쉽게, stream()]*

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

#Chain 선언
model = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_template("tell me a joke about {topic}")
chain = prompt | model

#Chain의 stream()함수를 통해 스트리밍 기능 추가
for s in chain.stream({"topic": "bears"}):
    print(s.content, end="", flush=True)

[한꺼번에 여러 개 API 요청하고 답변 받기, batch()]

- 5개 문장 번역 batch 수행

%%time
model = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_template("다음 한글 문장을 프랑스어로 번역해줘 {sentence}")
chain = prompt | model

chain.batch([
    {"sentence": "그녀는 매일 아침 책을 읽습니다."},
    {"sentence": "오늘 날씨가 참 좋네요."},
    {"sentence": "저녁에 친구들과 영화를 볼 거예요."},
    {"sentence": "그 학생은 매우 성실하게 공부합니다."},
    {"sentence": "커피 한 잔이 지금 딱 필요해요."}

])

- 1개 문장 번역 invoke 수행

%%time
prompt = ChatPromptTemplate.from_template("다음 한글 문장을 프랑스어로 번역해줘 {sentence}")
chain = prompt | model

chain.invoke({"sentence": "그녀는 매일 아침 책을 읽습니다."})

## RunnablePassthrough, RunnableLambda, RunnableParallel****

[RunnablePassthrough]

*RunnablePassthrough는 가장 단순한 Runnable 객체로, 들어온 입력을 그대로 전달합니다.*

pip install -q langchain langchain-core langchain-openai

import os
os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"

from langchain_core.runnables import RunnablePassthrough

RunnablePassthrough().invoke("안녕하세요")

Langchain을 표현하는 언어, LCEL

[LCEL로 기본 체인 구성하기]
import os
os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"

필수 라이브러리 설치

!pip install --upgrade --quiet langchain openai langchain-core langchain-openai
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

프롬프트 템플릿 설정

prompt = ChatPromptTemplate.from_template("tell me a short joke about {topic}")

LLM 호출

model = ChatOpenAI(model="gpt-4o-mini")

출력 파서 설정

output_parser = StrOutputParser()

LCEL로 프롬프트템플릿-LLM-출력 파서 연결하기

chain = prompt | model | output_parser

invoke함수로 chain 실행하기

chain.invoke({"topic": "ice cream"})
[Streaming 기능 추가를 더욱 쉽게, stream()]
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

Chain 선언

model = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_template("tell me a joke about {topic}")
chain = prompt | model

Chain의 stream()함수를 통해 스트리밍 기능 추가

for s in chain.stream({"topic": "bears"}):
print(s.content, end="", flush=True)
[한꺼번에 여러 개 API 요청하고 답변 받기, batch()]

5개 문장 번역 batch 수행 %%time model = ChatOpenAI(model="gpt-4o-mini") prompt = ChatPromptTemplate.from_template("다음 한글 문장을 프랑스어로 번역해줘 {sentence}") chain = prompt | model

chain.batch([
{"sentence": "그녀는 매일 아침 책을 읽습니다."},
{"sentence": "오늘 날씨가 참 좋네요."},
{"sentence": "저녁에 친구들과 영화를 볼 거예요."},
{"sentence": "그 학생은 매우 성실하게 공부합니다."},
{"sentence": "커피 한 잔이 지금 딱 필요해요."}

])

1개 문장 번역 invoke 수행 %%time prompt = ChatPromptTemplate.from_template("다음 한글 문장을 프랑스어로 번역해줘 {sentence}") chain = prompt | model

chain.invoke({"sentence": "그녀는 매일 아침 책을 읽습니다."})

RunnablePassthrough, RunnableLambda, RunnableParallel

[RunnablePassthrough]RunnablePassthrough는 가장 단순한 Runnable 객체로, 들어온 입력을 그대로 전달합니다.
pip install -q langchain langchain-core langchain-openai
import os
os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"
from langchain_core.runnables import RunnablePassthrough

RunnablePassthrough().invoke("안녕하세요")
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_template("다음 한글 문장을 프랑스어로 번역해줘 {sentence} \n French sentence: (print from here)")
model = ChatOpenAI(model="gpt-4o-mini")
output_parser = StrOutputParser()

runnable_chain = {"sentence": RunnablePassthrough()} | prompt | model | output_parser

runnable_chain.invoke({"sentence": "그녀는 매일 아침 책을 읽습니다."})
RunnablePassthrough는 assin 함수를 통해 새로운 변수에 계산된 값을 입력할 수 있습니다.
(RunnablePassthrough.assign(mult=lambda x: x["num"]*3)).invoke({"num":3})
from langchain_core.runnables import RunnableParallel, RunnablePassthrough

runnable = RunnableParallel(
extra=RunnablePassthrough.assign(mult=lambda x: x["num"] * 3),
modified=lambda x: x["num"] + 1,
)

runnable.invoke({"num": 1})
[RunnableLambda]RunnableLambda는 임의의 함수를 Chain에 결합할 수 있게 Runnable 객체로 변환합니다..
def add_smile(x):
return x + ":)"
from langchain_core.runnables import RunnableLambda

add_smile = RunnableLambda(add_smile)
from langchain.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser

prompt_str = "{topic}의 역사에 대해 세문장으로 설명해주세요."
prompt = ChatPromptTemplate.from_template(prompt_str)

model = ChatOpenAI(model_name = 'gpt-4o-mini')

output_parser = StrOutputParser()

chain = prompt | model | output_parser
from langchain_core.runnables import RunnableLambda

def add_thank(x):
return x + " 들어주셔서 감사합니다 :)"

add_thank = RunnableLambda(add_thank)
chain = prompt | model | output_parser | add_thank
chain.invoke("반도체")
pip install -q grandalf
chain.get_graph().print_ascii()
[RunnableParallel]RunnableParallel은 여러 요소가 병렬 처리되도록 처리합니다.
from langchain_core.runnables import RunnableParallel, RunnablePassthrough

runnable = RunnableParallel(
passed=RunnablePassthrough(),
modified=lambda x: x["num"] + 1,
)

runnable.invoke({"num": 1})
runnable = RunnableParallel(
passed=RunnablePassthrough(),
modified=add_thank,
)
runnable.invoke("안녕하세요")
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableParallel
from langchain_openai import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser

model = ChatOpenAI(model = 'gpt-4o-mini', max_tokens = 128, temperature = 0)

history_prompt = ChatPromptTemplate.from_template("{topic}가 무엇의 약자인지 알려주세요.")
celeb_prompt = ChatPromptTemplate.from_template("{topic} 분야의 유명인사 3명의 이름만 알려주세요.")

output_parser = StrOutputParser()

history_chain = history_prompt | model | output_parser
celeb_chain = celeb_prompt | model | output_parser

map_chain = RunnableParallel(history=history_chain, celeb=celeb_chain)

result = map_chain.invoke({"topic": "AI"})
result

LCEL로 RAG 구축하기

[기본 RAG 구축]
pip install -q langchain_chroma langchain_community langchainhub
from langchain_openai import ChatOpenAI
import bs4
from langchain import hub
from langchain_chroma import Chroma
from langchain_community.document_loaders import WebBaseLoader
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter

model = ChatOpenAI(model="gpt-4o-mini")

Load, chunk and index the contents of the blog.

loader = WebBaseLoader(
web_paths=("https://n.news.naver.com/mnews/article/366/0001007619",),
bs_kwargs=dict(
parse_only=bs4.SoupStrainer(
class_=("newsct_article _article_body")
)
),
)
docs = loader.load()

text_splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)
splits = text_splitter.split_documents(docs)
vectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings())

Retrieve and generate using the relevant snippets of the blog.

retriever = vectorstore.as_retriever()
prompt = hub.pull("rlm/rag-prompt")

def format_docs(docs):
return "\n\n".join(doc.page_content for doc in docs)

rag_chain = (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| prompt
| model
| StrOutputParser()
)

rag_chain.invoke("아까 내가 했던 질문이 뭐야?")

메모리를 추가한 RAG 구축하기

from langchain.chains import create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain.chains import create_history_aware_retriever
from langchain_core.prompts import MessagesPlaceholder
from langchain_core.messages import HumanMessage

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splits = text_splitter.split_documents(docs)
vectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings())
retriever = vectorstore.as_retriever()
contextualize_q_system_prompt = (
"Given a chat history and the latest user question "
"which might reference context in the chat history, "
"formulate a standalone question which can be understood "
"without the chat history. Do NOT answer the question, "
"just reformulate it if needed and otherwise return it as is."
)

contextualize_q_prompt = ChatPromptTemplate.from_messages(
[
("system", contextualize_q_system_prompt),
MessagesPlaceholder("chat_history"),
("human", "{input}"),
]
)
history_aware_retriever = create_history_aware_retriever(
model, retriever, contextualize_q_prompt
)
system_prompt = (
"You are an assistant for question-answering tasks. "
"Use the following pieces of retrieved context to answer "
"the question. If you don't know the answer, say that you "
"don't know. Use three sentences maximum and keep the "
"answer concise."
"\n\n"
"{context}"
)
qa_prompt = ChatPromptTemplate.from_messages(
[
("system", system_prompt),
MessagesPlaceholder("chat_history"),
("human", "{input}"),
]
)
question_answer_chain = create_stuff_documents_chain(model, qa_prompt)

rag_chain = create_retrieval_chain(history_aware_retriever, question_answer_chain)

chat_history = []

question = "오픈AI 근황은 어때?"
ai_msg_1 = rag_chain.invoke({"input": question, "chat_history": chat_history})
chat_history.extend([HumanMessage(content=question), ai_msg_1["answer"]])
ai_msg_1
chat_history
question = "다시 한번 설명해줄래?"
ai_msg_2 = rag_chain.invoke({"input": question, "chat_history": chat_history})
chat_history.extend([HumanMessage(content=question), ai_msg_2["answer"]])
ai_msg_2
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

store = {}

def get_session_history(session_id: str) -> BaseChatMessageHistory:
if session_id not in store:
store[session_id] = ChatMessageHistory()
return store[session_id]

conversational_rag_chain = RunnableWithMessageHistory(
rag_chain,
get_session_history,
input_messages_key="input",
history_messages_key="chat_history",
output_messages_key="answer",
)
conversational_rag_chain.invoke(
{"input": "오픈AI의 근황이 어때?"},
config={
"configurable": {"session_id": "abc123"}
}, # constructs a key "abc123" in store.
)["answer"]
conversational_rag_chain.invoke(
{"input": "앞으로 어떻게 될까?"},
config={"configurable": {"session_id": "abc123"}},
)["answer"]
from langchain_core.messages import AIMessage

for message in store["abc123"].messages:
if isinstance(message, AIMessage):
prefix = "AI"
else:
prefix = "User"

print(f"{prefix}: {message.content}\\n")

파이썬의 주요 특징

otololism — Sat, 25 Apr 2026 06:05:06 +0000

파이썬의 주요 특징

파이썬은 다음과 같은 다양한 특징과 장점을 가지고 있습니다:

읽기 쉬운 문법: 파이썬은 간결하고 읽기 쉬운 문법을 가지고 있어 초보자도 쉽게 배울 수 있습니다. 코드의 가독성이 높아 유지보수가 용이합니다.
광범위한 라이브러리: 파이썬은 데이터 분석, 웹 개발, 머신러닝, 과학 계산 등 다양한 분야에 활용할 수 있는 풍부한 라이브러리를 제공합니다. 예를 들어, 데이터 분석에는 pandas, 웹 개발에는 Django, 머신러닝에는 scikit-learn 등이 있습니다.
플랫폼 독립성: 파이썬은 운영 체제에 상관없이 동일한 코드를 실행할 수 있습니다. 이는 다양한 환경에서 개발과 배포를 용이하게 합니다.
대화형 인터프리터: 파이썬은 대화형 인터프리터를 제공하여, 즉시 결과를 확인하며 개발할 수 있습니다. 이를 통해 빠른 프로토타이핑과 디버깅이 가능합니다.
커뮤니티 지원: 파이썬은 전 세계적으로 활발한 개발자 커뮤니티를 가지고 있어, 다양한 자료와 도움을 쉽게 얻을 수 있습니다.

파이썬 설치하기

공식홈페이지에 다운받아 설치합니다.

주의사항:

Add Pyhton 3.6 to PATH (패스경로) 옵션 체크,

경로를 해매지 않으려면 커스텀으로 C:\Python36폴더에 설치하는 것이 편함.

만약 설치가 꼬여서 매번 패스 찾기가 예매하면

시스템 환경 고급에서

환경 변수의 경로를 C:\Python36과C:\Python36\Scripts\를 추가해 주고 재부팅하면 됨.

변수와 값

변수는 저장해 놓는 공간

변수는 숫자가 될 수 없다.

a = b

a = 1

파이썬의 자료형

type(a)

int실수

flot정수

+,-,*,/ 사칙연산

//나누기의 몫

%나누기의 나머지

**제곱

정수, 실수, 변수, 함수,

type(a)

True, Fale, None, Bool

자료형(str문자열)

a = ’hello’

print(a) #자료형을 출력해주는 함수

/n 줄바꿈 /다음에 나오는 문자는 이스케이프 문자로 인식 /n 내림 /t 텝

문자열 인덱싱

문자열을 꺼내옴 ab cde 는 [a][b][_][c][d][e] 문자열의 번호는 > 0,1,2,3,4,5,6 <-의 순서 index라고 한다.

문자열을 잘라오고 [시작:끝] 을 slice

문자열 포멧 변수 format

a= “나는 {1}살 이고 기록이 {0}입니다.”.format(old.s) # 1번{}<old로 2번{}<s로 {위치값}

따라서 {변수}면 들어간다. 출력하면 알아서 나온다.

“{0:=*^30}”.format(”안녕”) # ===============안녕=================

”*15+ ”안녕” + “15” #===============안녕=================

문자열 함수(메서드) #변수=문자열

찾는 함수 변수.find(”012345”) 찾는데 없으면 기본값은 -1

순서 함수 변수,index(”012345”)

변수[변수.rfind(”특정값”):]

찾을때,바꿀때 변수.replace("찾을문자", "바꿀문자", [바꿀횟수])

자르기,매우기 변수.split(”자를변수값”)

대문자함수 변수.upper()

소문자함수 변수.low()

문자열개수&카운터 z= “aaabbc” / z.count(”a”) / a = 3 /

총단위수함수 변수.len(a) / 6

#리스트 list 표기[] 중괄호 설명: 내용가변

#소괄호 tuple 표기() 소괄호 설명: 내용불변

패킹: 패키징하기 #변수선언과 같음.

언패킹: 튜플에서 값을 꺼내오기 #순서를 가져

그밖의 함수

문자 찾기 isalpha()

정수? isdecimal()

10진수? isdigit()

숫의개념? isnumeric()

참고: 함수찾아 보기 dir(str) 함수의 디렉도리(매소드)를 출력해라!

파이썬의 대이터 구조 (0부터 순서~)

대괄호 리스트[] 설명: 내용가변~ list

추가함수 append([추가}) [추가] 객체 그 자체 추가

추가함수. extend([추가]) 추가 변수의 요소 추가

삽입함수 insert(어디에,추가)

삭제함수 del(번쩨:값)

지우기함수 remove(값)

꺼내기함수 pop(꺼내기)

합치기 + 합치기함수 extend #참조: append()를 하면 문자열 자체로 결함

정렬합수 sort() 역정렬함수 revesel()

검출 in 값 in 변수 변수에 값을 확 True & False 로 확인

딕셔너리 dict()

중괄호 딕셔너리{}: key”키”와 value”값”이 쌍으로 하나의 객체(object)를 만든다. 키로 값에 접근

a = {”키”:”값”} #키는 중복 될 수 없으며 값은 변한다. 변수a에 객체를 넣는다.

이러한 객체는 함수del()로 지울수 있고 함수pop()으로 꺼낼 수 도 있다.

객체도 함수를 통해 변수 처럼 사용 한다. update

객체는 “,” 컴마로 이어쓸 수 있고 ⏎으로 내려 사용할 수 있다.

변수(Variable): 특정 메모리 주소에 저장된 값을 가리키는 이름표(label) 또는 식별자(identifier)입니다. 새로운 값을 할당하여 변경할 수 있습니다.
딕셔너리 값 (Dictionary Value): 딕셔너리 내의 특정 키(key)와 연결된 실제 데이터(예: 숫자, 문자열, 다른 딕셔너리, 리스트 등 Values) 또는 해당 데이터가 저장된 메모리 위치를 가리키는 참조입니다.

딕셔너리의 가져오는 함수들

키 함수 key() 값 함수 values() 객체 함수 items() 없으면 오류 get()은 없어도 넘어간다.

집합의 함수

set() 집합은 중복이 없다. set([]) &교 |합 -차 로 출력 된다.

변수에 추가 .add(값) 업데이트 .updata() 삭제 .del() 하여 사용 된다.

형변환

중복이 되어 있는 변수는 set() 함수를 통해 중복을 제거할 수 있다.

“숫자” = str 형태 int( 숫자)는 정수(Integer) float(숫자)는 실수(Real Number)가 된다.

함수의 성질의 값으로 객체를 변화 시킴 Int() float() type()

int(문자)가 들어가면 “ValueError” 값오류가 나온다.

참고: 신택스에러,

SyntaxError: invalid syntax: 문법:구문 오류

IndentationError: unexpected inden: 들여쓰기 잘못, 탭과 공백이 혼합

💡

파이썬의 코드컨밴션 규칙

(AI에게 코드를 맡긴다고 하면 일관성 유지를 위해 코드컨밴센의 원칙을 프롬프트 해야 함.)

공통 규칙

들여쓰기는 공백 4칸을 사용. tab 사용 불가
각 줄의 최대 길이는 79자로 제한. 길어질 경우 \ 또는 괄호를 사용하여 다음줄로 나눔
모듈 레벨 함수 및 클래스 정의는 두줄 간격으로 작성
괄호, 중괄호, 대괄호 내부에는 공백 사용 금지
쉼표, 콜론, 세미콜론 앞에 공백 사용 금지. 뒤에는 공백 사용
주석은 한 줄의 경우 #을 사용하고 코드와 두칸의 공백을 둠. 여러 줄의 경우 """을 사용
docstring 작성시 """을 사용

변수 및 함수

변수 및 함수명은 영어소문자 및 밑줄(_)로 구성된 snake_case로 작성
상수는 영어대문자 및 밑줄(_)로 작성. 모듈 수준에서만 작성.
연산자 앞뒤에 공백 사용
문자열의 경우 쌍따옴표(")를 사용
함수의 docstring은 함수에 대한 설명, args, return에 대한 설명을 포함
함수 정의시 typing과 hint를 사용하여 타입 명명
bool 값 비교시 is 또는 is not을 사용
한 줄 조건문은 삼항 연산자를 사용
간단한 함수의 경우 lambda 사용
글로벌 변수의 경우 모듈내에서만 사용하고 g_로 시작 자료구조
list와 dict 초기화시 list(), dict() 사용
set과 tuple 초기화시 set(), tuple() 사용
간단한 list의 경우 list comprehension을 사용

클래스

클래스명은 CamelCase로 작성
클래스 상속시, 상위부모부터 순서대로 작성.
클래스내 메서드는 한줄 간격으로 작성.
메서드명은 snake_case로 작성
private의 경우 두 개의 밑줄(__)로 시작
protected의 경우 한 개의 밑줄(_)로 시작
타입 검사시 isinstance()를 사용
클래스 변수는 클래스명과 밑줄(_)로 구분
클래스 정의시 생성자와 소멸자, str은 필수로 작성 모듈 및 패키지
각 패키지 및 모듈은 별도의 줄에 작성
표준 라이브러리, 서드 파티 모듈, 로컬 모듈 순서로 작성
모듈명은 영어 소문자로 작성

파일 입출력

파일을 열 때는 with을 사용하여 자동으로 닫히도록 함.
로그 작성시 날짜와 시간은 반드시 포함할 것.

조건문 :

if 일때 조건 변수==(! =)값 : 같으면 다음으로

> = 이상

< 이전

and 그리고

and not 그렇지않고

or 또는

elif 조건 그렇지 않고

else: 위 전부 아니라면 다음으로

score = int(input("점수를 입력하세요 (0~100): "))
attendance = float(input("출석률을 입력하세요 (0~100): "))

# 1. 기본 범위 체크 (비교 연산자, 논리 연산자)
if score < 0 or score > 100 or attendance < 0 or attendance > 100:
    print("입력 값이 유효 범위를 벗어났습니다.")
else:
    # 2. 중첩 if: 과락(40점 미만) 먼저 체크
    if score < 40:
        print("결과: 불합격 (과락)")
    else:
        # 3. 다중 조건 if-elif-else로 등급 산정
        if score >= 90 and attendance >= 80:
            grade = "A"
        elif score >= 80 and attendance >= 75:
            grade = "B"
        elif score >= 70 and attendance >= 70:
            grade = "C"
        elif score >= 60:
            grade = "D"
        else:
            grade = "F"

        # 4. 추가 조건: 우수/경고 태그 부여 (중첩 if, not, 비교 연산자)
        tag = ""
        if grade in ("A", "B") and attendance >= 90:
            tag = " (우수)"
        elif grade == "D" and not (attendance >= 70):
            tag = " (출석 경고)"

        print(f"점수: {score}, 출석률: {attendance}%")
        print(f"최종 등급: {grade}{tag}")

반복문 while :

while 조건에 맞을 때 까지 반복

guest = 1
while guest < 10:
    print("손님이 {} 명 입니다.".format(guest))
    guest = guest + 1
    if guest == 10:
        print("손님이 꽉 찼습니다.")

num = 1
while num <= 10:
    if num % 2 == 0:
        print("짝 {}".format(num))
    else:
        print("홀 {}".format(num))
    num = num + 1

num = 1
hap = 0
while num <= 100:
    hap += num
    num += 1

print(hap)

반복문 for :

for 순차적인 요소가 있을 경우

요소함수 enumerate(요소[,start=])

a = "abcdef"
for i in a:
    print(i)

# range()는 차순반복함수  +(더하면서)를 하면서 (1, 10, 2) 1부터 10까지 2씩 넘어가기의 의미

for i in  range(1,5+1): 
print(1)

student = [{"홍길동": 100}, {"가체즈": 200}, {"가가멜": 300}]

for s, i in enumerater(student, start=1):
    data = (list(i.items())[0])
    name = data[0]
    value = data[1]
    print("{} 이름: {} 점수: {}".format(s, name, value))

result = []
for num in range(1, 6):
    result.append(num + 5)
print(result)

result = [num + 5 for num in range(1, 6)]
print(result)

result = [num * 3 for num in range(1, 99) if num % 2 == 0] # 묶어쓰기

for num in range(1, 99): #풀어쓰기
    if num % 2 == 0:
        result.append(num * 3)

for i in range(2, 10):
    for j in range(1, 10):
        result = i * j
        gugudan = ("{} X {} = {}".format(i, j, result))
        print(gugudan)

# gugudan = [i * j for i in range(2, 10) for j in range(1, 10)]
# print(gugudan)

묶어쓰기와 풀어쓰기를 자유자제로 쓸 수 있도록 반복 훈련 중요

cotinue 걸려저서 나온 것에 반복

for i in range(1, 100):
    if i % 2 == 0:
        continue
    hap += i

print("홀수의 합 {}".format(hap))

break 조건에 걸리면 정지

num = 0
for i in range(1, 100):
    for j in range(100):
        print(i,j)
        if j == 10:
            break

사용자 입력 받기

user = input("사용자 이름을 입력하세요.>")
print(user)

num1 = int(input("숫자1"))
num2 = int(input("숫자2"))
print(num1 + num2)

langs = ["한국어", "English"]
for i, 1 in enumerate(langs, starts=1):
    print("{}. {}".format(i, 1))

while True:
    sel = input("언어를 선택하세요.>"
    if not sel.isnumeric():
        continue
    sel = int(sel)
    if 0 < sel < 3:
        break

print("사용자가 선택한 언어는 {} 입니다.".format(langs[sel-1]))

파일 읽고 쓰기

내장함수 100선

No.	Category	Function	Description	Example Code # 결과값
1	Type Conversion	abs()	절대값 반환	print(abs(-5)) # 5
2	Type Conversion	int()	정수형으로 변환	x = int('42'); print(x) # 42
3	Type Conversion	float()	부동소수점으로 변환	y = float('3.14'); print(y) # 3.14
4	Type Conversion	str()	문자열로 변환	s = str(123); print(s) # '123'
5	Type Conversion	bool()	부울값으로 변환	b = bool(1); print(b) # True
6	Type Conversion	list()	리스트로 변환	lst = list('abc'); print(lst) # ['a', 'b', 'c']
7	Type Conversion	tuple()	튜플로 변환	tpl = tuple([1, 2]); print(tpl) # (1, 2)
8	Type Conversion	dict()	딕셔너리로 변환	d = dict([('a', 1)]); print(d) # {'a': 1}
9	Type Conversion	set()	집합으로 변환	s = set([1, 2, 2]); print(s) # {1, 2}
10	Type Conversion	complex()	복소수로 변환	c = complex(1, 2); print(c) # (1+2j)
11	Type Check	type()	객체의 타입 반환	print(type(42)) #
12	Type Check	isinstance()	객체가 특정 타입인지 확인	print(isinstance(42, int)) # True
13	Type Check	callable()	객체가 호출 가능한지 확인	print(callable(print)) # True
14	Sequence	len()	시퀀스 길이 반환	print(len([1, 2, 3])) # 3
15	Sequence	max()	최댓값 반환	print(max([3, 1, 2])) # 3
16	Sequence	min()	최솟값 반환	print(min([3, 1, 2])) # 1
17	Sequence	sum()	요소의 합 반환	print(sum([1, 2, 3])) # 6
18	Sequence	sorted()	정렬된 리스트 반환	print(sorted([3, 1, 2])) # [1, 2, 3]
19	Sequence	reversed()	역순 이터레이터 반환	list(reversed([1, 2, 3])) # [3, 2, 1]
20	Sequence	enumerate()	인덱스와 값 반환	for i, v in enumerate(['a']): print(i, v) # 0 a
21	Sequence	zip()	여러 시퀀스 묶음	list(zip([1, 2], ['a', 'b'])) # [(1, 'a'), (2, 'b')]
22	Iterator	iter()	이터레이터 객체 반환	it = iter([1, 2]); next(it) # 1
23	Iterator	next()	이터레이터의 다음 요소 반환	it = iter([1, 2]); print(next(it)) # 1
24	Functional	map()	함수를 시퀀스에 적용	list(map(str, [1, 2])) # ['1', '2']
25	Functional	filter()	조건에 맞는 요소 필터링	list(filter(lambda x: x > 1, [1, 2])) # [2]
26	Functional	reduce()	누적 함수 적용 (functools)	reduce(lambda x, y: x+y, [1, 2, 3]) # 6
27	Functional	lambda	익명 함수 정의	f = lambda x: x*2; print(f(5)) # 10
28	Functional	all()	모든 요소가 참인지 확인	print(all([True, True])) # True
29	Functional	any()	하나 이상 참인지 확인	print(any([False, True])) # True
30	String	ord()	문자의 유니코드 값 반환	print(ord('A')) # 65
31	String	chr()	유니코드 값의 문자 반환	print(chr(65)) # 'A'
32	String	format()	문자열 포맷팅	'{} {}'.format('Hello', 'World') # 'Hello World'
33	String	repr()	객체의 문자열 표현 반환	print(repr('hello')) # "'hello'"
34	String	ascii()	ASCII 표현 반환	print(ascii('café')) # "'caf\xe9'"
35	Numeric	pow()	거듭제곱 계산	print(pow(2, 3)) # 8
36	Numeric	round()	숫자 반올림	print(round(3.7)) # 4
37	Numeric	divmod()	몫과 나머지 반환	print(divmod(10, 3)) # (3, 1)
38	Numeric	hex()	16진수 문자열 반환	print(hex(255)) # '0xff'
39	Numeric	oct()	8진수 문자열 반환	print(oct(8)) # '0o10'
40	Numeric	bin()	2진수 문자열 반환	print(bin(8)) # '0b1000'
41	Dictionary	dict.get()	키 값 반환 (기본값 지정 가능)	d = {'a': 1}; print(d.get('b', 0)) # 0
42	Dictionary	dict.keys()	모든 키 반환	d = {'a': 1}; list(d.keys()) # ['a']
43	Dictionary	dict.values()	모든 값 반환	d = {'a': 1}; list(d.values()) # [1]
44	Dictionary	dict.items()	키-값 쌍 반환	d = {'a': 1}; list(d.items()) # [('a', 1)]
45	Dictionary	dict.pop()	키 제거 및 값 반환	d = {'a': 1}; d.pop('a') # 1
46	Dictionary	dict.update()	딕셔너리 업데이트	d = {'a': 1}; d.update({'b': 2}) # {'a': 1, 'b': 2}
47	List	list.append()	리스트 끝에 요소 추가	lst = [1]; lst.append(2) # [1, 2]
48	List	list.extend()	리스트 확장	lst = [1]; lst.extend([2, 3]) # [1, 2, 3]
49	List	list.insert()	특정 위치에 요소 삽입	lst = [1, 3]; lst.insert(1, 2) # [1, 2, 3]
50	List	list.remove()	첫 번째 일치 요소 제거	lst = [1, 2]; lst.remove(1) # [2]
51	List	list.pop()	인덱스 요소 제거 및 반환	lst = [1, 2]; lst.pop(0) # 1
52	List	list.clear()	모든 요소 제거	lst = [1, 2]; lst.clear() # []
53	List	list.index()	요소의 인덱스 반환	lst = [1, 2]; lst.index(2) # 1
54	List	list.count()	요소의 개수 반환	lst = [1, 1, 2]; lst.count(1) # 2
55	List	list.sort()	리스트 정렬	lst = [3, 1]; lst.sort() # [1, 3]
56	List	list.reverse()	리스트 역순	lst = [1, 2]; lst.reverse() # [2, 1]
57	String	str.split()	문자열 분할	s = 'a,b'; s.split(',') # ['a', 'b']
58	String	str.join()	문자열 결합	''.join(['a', 'b']) # 'ab'
59	String	str.strip()	양쪽 공백 제거	' hello '.strip() # 'hello'
60	String	str.replace()	문자열 대체	'hello'.replace('h', 'H') # 'Hello'
61	String	str.upper()	대문자로 변환	'hello'.upper() # 'HELLO'
62	String	str.lower()	소문자로 변환	'HELLO'.lower() # 'hello'
63	String	str.find()	부분 문자열 위치 반환	'hello'.find('ll') # 2
64	String	str.startswith()	문자열로 시작하는지 확인	'hello'.startswith('he') # True
65	String	str.endswith()	문자열로 끝나는지 확인	'hello'.endswith('lo') # True
66	String	str.isdigit()	모두 숫자인지 확인	'123'.isdigit() # True
67	String	str.isalpha()	모두 문자인지 확인	'abc'.isalpha() # True
68	String	str.isalnum()	모두 문자 또는 숫자인지 확인	'abc123'.isalnum() # True
69	String	str.isspace()	모두 공백인지 확인	' '.isspace() # True
70	Input/Output	print()	화면에 출력	print('Hello', 'World') # Hello World
71	Input/Output	input()	사용자 입력 받음	name = input('Name: ') # 사용자 입력 저장
72	Input/Output	open()	파일 열기	f = open('file.txt'); f.close() # 파일 열고 닫기
73	Input/Output	format()	문자열 포맷팅	f'{x:.2f}' # 소수점 2자리로 표현
74	Memory	id()	객체의 메모리 주소 반환	print(id([1])) # 메모리 주소
75	Memory	hash()	객체의 해시값 반환	hash((1, 2)) # 해시값
76	Memory	dir()	객체의 속성 및 메서드 나열	dir(list) # 리스트의 메서드 리스트
77	Memory	vars()	객체의 dict 반환	vars(obj) # 객체의 속성 딕셔너리
78	Memory	globals()	전역 심볼 테이블 반환	print(globals()['name']) # 'main'
79	Memory	locals()	지역 심볼 테이블 반환	def f(): print(locals()) # 지역 변수 딕셔너리
80	Iteration	range()	숫자 시퀀스 반환	list(range(3)) # [0, 1, 2]
81	Iteration	slice()	슬라이스 객체 생성	s = slice(1, 3); [0, 1, 2][s] # [1, 2]
82	Object	getattr()	객체 속성값 반환	getattr(obj, 'attr', None) # 속성값
83	Object	setattr()	객체 속성값 설정	setattr(obj, 'attr', value) # 속성 설정
84	Object	hasattr()	객체가 속성을 가지는지 확인	hasattr(obj, 'attr') # True/False
85	Object	delattr()	객체 속성 삭제	delattr(obj, 'attr') # 속성 삭제
86	Object	object	모든 클래스의 기본 클래스	class MyClass(object): pass # 객체 상속
87	Class	super()	부모 클래스 메서드 호출	super().init() # 부모 클래스 초기화
88	Class	classmethod	클래스 메서드 데코레이터	@classmethod def method(cls): pass
89	Class	staticmethod	정적 메서드 데코레이터	@staticmethod def method(): pass
90	Class	property	속성 데코레이터	@property def attr(self): return self._attr
91	Execution	exec()	파이썬 코드 실행	exec('x = 1 + 1'); print(x) # 2
92	Execution	eval()	표현식 계산	eval('2 + 2') # 4
93	Execution	compile()	파이썬 코드 컴파일	code = compile('x=1', '', 'exec')
94	Module	import	모듈 임포트	import math; print(math.pi) # 3.14159...
95	Module	import	모듈 동적 임포트	mod = import('math') # 모듈 로드
96	Control	exit()	프로그램 종료	exit() # 프로그램 종료
97	Control	quit()	인터프리터 종료	quit() # 대화형 모드 종료

사용자 함수

기초지식

매개변수(파라메타, 파람, 인지값): 함수에 인뭇 데이터를 전달하기 위한 변수

지역변수 = 개인 사물함

전역변수 = 공용 사물함

집에서 방마다 사물함이 있다고 상상해 보자. 지역변수는 각 방(함수) 안의 개인 사물함처럼 그 방에서만 쓸 수 있고, 방을 나가면 사라진다. 반대로 전역변수는 집 전체(프로그램)의 공용 사물함처럼 어느 방에서도 쓸 수 있고, 집이 문 닫힐 때까지 남아 있다.

# 전역변수: 집 전체에서 공유 (공용 사물함)
# 이 코드에서 money(global variable)는 함수 밖에서 선언되어 모든 함수에서 접근 가능하며, 
# data segment에 저장되어 프로그램 lifetime 동안 지속된다. 
# 반면 candy_price, toy_price(local variables)는 함수 블록 내에서만 유효하며, 
# 함수 종료 시 stack에서 자동 해제된다.

money = 1000  # 프로그램 시작 시 생성, 종료까지 유지

def eat_candy():  # 방1: 사탕 사먹기
    candy_price = 200  # 지역변수: 이 방에서만 (개인 사물함)
    money -= candy_price  # 공용 사물함에서 돈 빼기
    print(f"사탕 사먹고 돈 남음: {money}원")  # 800원 출력

def buy_toy():  # 방2: 장난감 사기
    toy_price = 500  # 지역변수: 이 방에서만 (다른 방에선 못 봄)
    print(f"장난감 가격: {toy_price}원")  # 500원 출력
    # candy_price는 여기서 못 씀! (NameError 발생)

eat_candy()  # 800원 출력
buy_toy()    # 500원 출력
print(f"최종 돈: {money}원")  # 800원 출력 (전역변수 유지)

구분	지역변수 (Local)	전역변수 (Global)
선언 위치	함수/블록 내부	함수 외부
접근 범위	선언된 블록 내 한정	프로그램 전체
수명	블록 종료 시 소멸	프로그램 종료 시 소멸
메모리	Stack (빠름)	Data segment
Best Practice	우선 사용 (모듈화 ↑)	최소화 (버그 위험 ↓)

****지역변수를 전역변수로 불러 오는 함수 global 변수

def get_input_user(msg, casting=int):
    while True:
        try:
            user_input = input(msg)

            # 이름 입력일 때, 빈 문자열이면 안내 후 다시 입력
            if casting is str and not user_inputstrs.strip():
                print("이름이 입력되지 않았습니다.")
                continue

            user = casting(user_input)
            return user
        except:
            continue

user = get_input_user("사용자 이름을 입력하세요> ", str)
age = get_input_user("사용자 나이를 입렵하세요> ")       # 1.casting=int (,int)생략
print(user, age)

뮤테이블(콜바이레퍼런스) List Dictionay

독스트링

포지셔널 아규먼트

키워드 아큐먼트

def get_input_user(msg, casting):
    '''독스트린: 리드미 사용자에게 msg를 출력하고 casting 형태를 확인하여 입력된 값을 리턴합니다.
    파이썬에서 독스트링(docstring)과 주석(comment)은 코드 가독성과 문서화를 위한 도구지만, 문법, 접근성, 용도에서 명확한 차이를 보인다.
    Args:
        msg (str) : input 시 출력할 문구
        castring (class) : 사용자에게 입력 받은 값
    '''
    while True:
        try:
            user_input = input(msg)
            # 공백만 입력했을 때는 다시 입력 요구
            if casting is str and not user_input.strip():
                print("이름이 입력되지 않았습니다.")
                continue
            return casting(user_input)
        except:
            # 형 변환 실패하면 다시 입력
            print("잘못된 입력입니다. 다시 입력하세요.")
            continue

def is_prime_number(num):
    prime_lists = [False, False] + [True] * (num - 1)
    primes = []
    for i in range(2, num + 1):
        if prime_lists[i]:
            for j in range(2 * i, num + 1, i):
                prime_lists[j] = False
    primes = [i for i in range(2, num + 1) if prime_lists[i] == True]

    if num in primes:
        return True
    else:
        return False

# 함수 밖에서 입력 및 출력 처리
num = get_input_user("2 이상의 숫자를 입력하세요> ", int)
if is_prime_number(num):
    print("{} 는 소수 입니다.".format(num))
else:
    print("{} 는 소수가 아닙니다. ".format(num))

def save_winner(*args): #튜플/ *args포지셔널 아규먼트 들어간 순서를 지켜 준다. *하나
    print(args)

def save_winner2(**kwargs): #     **kwargs 키워드 아규먼트 이름을 키를 주고 값을 같이 넘긴다. **둘
    print(kwargs)
    if kwrgs.get("name1"):
        print(kwargs["name1"]) #파이썬의 함수의 특징은 일급객체라고 하는데 함수를 변수의 닮을 수 있는 것이 특징



save_winner("홍길동")
save_winner("홍길동", "가가멜")
save_winner("홍길동", "가가멜", "아즈라엘")
save_winner2(namel1="홍길동", name2="가가멜")

def hi():
    print("Hello")

hello = hi # 
hello()   # hi함수는 ()로 닮을 수 있는 반면 hello라는 변수를 만들어서 hi를 직관적으로 닮을 수 있다.
print(type(hello)) # 오호~~~ 신기함. 진관적이라 이해가 좀 안감. 일단 암기

##함수 안네 함수 넣기
def outer_function(func):
    def inner_function(**args, **kwargs): #만약 어떤 인자가 넘어 올지 모르는 상황이면~
        print("함수명: )


              클로저 기술  일급 함수에 네임바인딩 기술?

파이썬 함수의 특징

(언젠가는 써먹는다 & 누군가(실력자)의 코드를 보고 대충 파악하려면 대충 알고 넘어가자~!)

파이썬에서 클로저는 “함수 + 그 함수가 기억해야 할 변수들(환경)을 한 덩어리로 묶어 둔 것”이고, 일급 함수는 “함수를 숫자처럼 변수에 넣고, 다른 함수에 주고, 다시 돌려줄 수 있는 것”을 말한다. 이름 바인딩(name binding)은 “이름(변수)이 실제 값(객체)을 가리키도록 연결하는 것”이고, 클로저는 그 연결을 함수 안에 꼭 붙들고 있는 기술이라고 보면 된다.

1. 일급 함수: 함수도 ‘장난감’이다

초등학생 비유로 설명해 보자.

“숫자”는 장난감처럼 상자에 넣을 수 있다 → x = 10
파이썬에서는 “함수”도 장난감처럼 상자에 넣을 수 있다 → f = hello

def hello(name):
    return "안녕, " + name

# 1) 함수 이름을 변수에 넣기 (이름 바인딩)
h = hello          # h라는 이름이 hello 함수를 가리킴

print(h("민수"))   # "안녕, 민수"

여기서 h = hello는 “h라는 이름을 hello라는 함수 객체에 바인딩한다(이름을 붙인다)”는 뜻이다.
함수가 숫자처럼 변수에 들어가고, 다른 함수에 넘겨질 수 있으니까 “일급 함수(first-class function)”라고 부른다.

2. 클로저: 기억을 가진 함수

이제 “기억하는 함수” 예제를 보자.

pythondef make_adder(x):        # x를 기억시키고 싶은 바깥 함수
    def adder(y):         # 안쪽 함수(클로저가 될 후보)
        return x + y      # 바깥의 x를 사용
    return adder          # 안쪽 함수를 그대로 돌려줌

add_5 = make_adder(5)     # x = 5를 기억하는 adder를 하나 만듦
add_10 = make_adder(10)   # x = 10을 기억하는 adder를 또 만듦

print(add_5(3))           # 5 + 3 = 8
print(add_10(3))          # 10 + 3 = 13

make_adder(5)를 호출할 때 x라는 이름은 값 5에 바인딩된다.
파이썬은 adder 함수 객체 안에 “x라는 이름은 5를 가리켜야 해”라는 정보를 같이 저장해 둔다.
이렇게 바깥 함수가 끝난 뒤에도, 안쪽 함수가 바깥 변수에 대한 이름 바인딩을 “기억”하는 것이 클로저다.

초등학생 버전 비유:

make_adder = “숫자를 기억하는 로봇을 만드는 공장”
add_5 = “5라는 숫자를 기억하는 로봇”
add_10 = “10이라는 숫자를 기억하는 로봇”
로봇 안에는 “내가 기억한 숫자” 칸이 있고, 이 칸을 통해 계속 계산을 한다 → 이 “내부 기억 칸”이 바로 클로저의 환경(environment)이다.

3. 이름 바인딩 기술: 클로저 안에서 어떻게 기억하나?

조금 더 “엔지니어 시점”으로 보면:

클로저는 “렉시컬 스코프 기반 name binding을 유지하는 레코드(환경) + 함수 코드”이다.
파이썬 함수 객체에는 __closure__라는 속성이 있고, 여기에 캡처된 변수들이 cell 객체 형태로 저장된다.

간단히 내부 구조를 엿보는 예:

pythondef outer():
    msg = "hello"        # 이 변수를 클로저가 캡처
    def inner():
        return msg       # 바깥 변수 사용
    return inner

fn = outer()             # 클로저 생성
print(fn())              # "hello"
print(fn.__closure__[0].cell_contents)  # "hello" 를 내부에서 들고 있음

msg라는 이름이 가리키는 실제 객체에 대한 참조가 __closure__ 안의 cell에 저장되어 있어서, outer가 끝나도 GC로 날아가지 않고 계속 살아 있다.
이 구조 덕분에 “클로저 = 함수가 만들어질 때의 이름 바인딩(환경)을 함께 싸서 들고 다니는 객체”로 동작한다.

4. 한 줄 정의들

일급 함수: “함수도 숫자처럼 상자(변수)에 넣고, 친구한테 건네줄 수 있는 언어의 기능”이다.
이름 바인딩: “이름표(변수)를 어떤 진짜 물건(값, 함수)에 붙여 주는 것”이다.
클로저: “밖에서 가져온 값을 기억한 채로 계속 써 먹는 똑똑한 함수”이고, 이때 기억을 유지하는 방식이 바로 ‘렉시컬 스코프 기반 이름 바인딩을 저장하는 레코드(환경)를 함수와 같이 들고 다니는 것’이다.

원하면, 위 예제를 가지고 “파이썬 Tutor 스타일”로 호출 스택/환경 그림을 같이 그려 주면서 더 포멀하게 정리해 줄 수 있다

DEV Community: otololism

RAG201 의 개념과 필요성

RAG201 의 개념과 필요성

LLM의 이해

LLM의 한계

개요

RAG의 개념

간단한 비유

설명

RAG파이프라인 개요와 핵심 컴포턴트

“자료 찾아서 똑똑하게 대답해 주는 챗봇(RAG)”만들기

1단계: 문서 불러오기 (Document Loader)

2단계: 문서 임베딩 (Embedding Model)

3단계: 벡터 DB 저장 및 검색 (Vector DB)

4단계: LLM 프롬프트 구성 및 답변 생성

전체 흐름 한 줄 정리

RAG를 활용하는 기업과 이에 산악협력하는 벤쳐기업들

Langchain 개념과 아키텍처

LangChain 개념

주요 아키텍처 컴포넌트

동작 원리

실무 예시

LLM의 발전과 함께 중요해진 프롬프트 엔지니어링을 보조할 수 있다.

프롬프트 엔지니어링이란?

Langchain을 사용한 RAG구현 워크플로우

RAG(Retrieval-Augmented Generation) 시스템의 단계별 공정

1. 문서 로드 및 수집 (Document Loading)

2. 텍스트 분할 (Text Splitting)

3. 벡터 임베딩 (Vector Embedding)

4. 벡터 데이터베이스 저장 (Vector Store)

5. 검색 및 유사 문장 추출 (Retrieval)

6. 답변 생성 (Generation)

## **Langchain을 표현하는 언어, LCEL**

*[LCEL로 기본 체인 구성하기]*

*[Streaming 기능 추가를 더욱 쉽게, stream()]

*[한꺼번에 여러 개 API 요청하고 답변 받기, batch()]*

- 5개 문장 번역 batch 수행

- 1개 문장 번역 invoke 수행

## **RunnablePassthrough, RunnableLambda, RunnableParallel**

*[RunnablePassthrough]*

Langchain을 표현하는 언어, LCEL

필수 라이브러리 설치

프롬프트 템플릿 설정

LLM 호출

출력 파서 설정

LCEL로 프롬프트템플릿-LLM-출력 파서 연결하기

invoke함수로 chain 실행하기

Chain 선언

Chain의 stream()함수를 통해 스트리밍 기능 추가

RunnablePassthrough, RunnableLambda, RunnableParallel

LCEL로 RAG 구축하기

Load, chunk and index the contents of the blog.

Retrieve and generate using the relevant snippets of the blog.

메모리를 추가한 RAG 구축하기

파이썬의 주요 특징

파이썬의 주요 특징

파이썬 설치하기

변수와 값

파이썬의 자료형

자료형(str문자열)

문자열 함수(메서드) #변수=문자열

#리스트 list 표기[] 중괄호 설명: 내용가변

#소괄호 tuple 표기() 소괄호 설명: 내용불변

그밖의 함수

대괄호 리스트[] 설명: 내용가변~ list

딕셔너리 dict()

중괄호 딕셔너리{}: key”키”와 value”값”이 쌍으로 하나의 객체(object)를 만든다. 키로 값에 접근

집합의 함수

형변환

참고: 신택스에러,

조건문 :

> = 이상

< 이전

and 그리고

반복문 while :

반복문 for :

사용자 입력 받기

파일 읽고 쓰기

내장함수 100선

사용자 함수

## Langchain을 표현하는 언어, LCEL****

[LCEL로 기본 체인 구성하기]

**[Streaming 기능 추가를 더욱 쉽게, stream()]*

[한꺼번에 여러 개 API 요청하고 답변 받기, batch()]

## RunnablePassthrough, RunnableLambda, RunnableParallel****

[RunnablePassthrough]