Ver3.0 ๐ค Python + LlamaIndex๋ก ๋ฌธ์ ๊ธฐ๋ฐ Q&A ๊ฐ๋ฐํ๊ธฐ

๐ค Python + LlamaIndex๋ก ๋ฌธ์ ๊ธฐ๋ฐ Q&A ๊ฐ๋ฐํ๊ธฐ
AI๊ฐ ๋ด ๋ฌธ์๋ฅผ ์ฝ๊ณ ์ฒ์ฒ ๋ต๋ณํด์ฃผ๋ ์์คํ ๋ง๋ค๊ธฐ ใ ใ ใ
์์ฆ ChatGPT ์ฐ๋ค๋ณด๋ฉด ์ง์ง ์ ๊ธฐํ์์์? ์ง๋ฌธํ๋ฉด ๋ฐ๋ก๋ฐ๋ก ๋ต๋ณํด์ฃผ๊ณ ใ
ใ
ใ
๊ทผ๋ฐ ์๊ฐํด๋ณด๋ฉด ์ฐ๋ฆฌ ํ์ฌ ๋ฌธ์๋ ๊ฐ์ธ ์๋ฃ๋ค์ ChatGPT๊ฐ ๋ชจ๋ฅด์์์? ๐ค
"์ ์ฐ๋ฆฌ ํ์ฌ ๋งค๋ด์ผ 1000ํ์ด์ง ๋๋๋ฐ ์ด๊ฑฐ AIํํ
ํ์ต์์ผ์ ์ง์๋ค์ด ๋ฌผ์ด๋ณด๋ฉด ๋ฐ๋ก ๋ต๋ณํด์ฃผ๊ฒ ํ ์ ์๋?"
์ด๋ฐ ์๊ฐ ํ๋ฒ์ฏค ํด๋ณด์
จ์ฃ ? ์ค๋์ ๋ฐ๋ก ๊ทธ๊ฑธ ๋ง๋๋ ๋ฐฉ๋ฒ์ ์๋ ค๋๋ฆด๊ฒ์! Python์ด๋ LlamaIndex๋ผ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฐ๋ฉด ์๊ฐ๋ณด๋ค ๊ฐ๋จํ๊ฒ ๊ตฌํ ๊ฐ๋ฅํฉ๋๋ค ๐ช
LlamaIndex๋ LLM(Large Language Model) ๊ธฐ๋ฐ ์ ํ๋ฆฌ์ผ์ด์
์ ๋ง๋ค ๋ ๋ฌธ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ฒ ์ฐ๊ฒฐํด์ฃผ๋ ํ๋ ์์ํฌ์์. ์ฝ๊ฒ ๋งํ๋ฉด GPT ๊ฐ์ AI ๋ชจ๋ธ์ด ์ฐ๋ฆฌ ๋ฌธ์๋ฅผ ์ฝ๊ณ ์ดํดํ ์ ์๊ฒ ๋์์ฃผ๋ ๋๊ตฌ๋ผ๊ณ ๋ณด์๋ฉด ๋ฉ๋๋ค ใ
ใ
์์ ์๋ ์ด๋ฐ ์์คํ
๋ง๋ค๋ ค๋ฉด ์ง์ง ๋ณต์กํ๊ฑฐ๋ ์? ๋ฌธ์ ํ์ฑํ๊ณ , ๋ฒกํฐ ์๋ฒ ๋ฉ ๋ง๋ค๊ณ , ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํํ๊ณ ... ๋จธ๋ฆฌ ์ํ์ฃ ๐ต
๊ทผ๋ฐ LlamaIndex ์ฐ๋ฉด ์ด ๋ชจ๋ ๊ณผ์ ์ด ๋ช ์ค์ ์ฝ๋๋ก ํด๊ฒฐ๋ฉ๋๋ค! ์ง์ง๋ฃจ์ ใ
ใ
ใ
์ ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์์ํด๋ณผ๊น์? ๋จผ์ ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ ์ค์นํด์ผ ํฉ๋๋ค. Python 3.8 ์ด์ ๋ฒ์ ์ด๋ฉด ๋ฉ๋๋ค!
ํฐ๋ฏธ๋์ด๋ ๋ช ๋ น ํ๋กฌํํธ์์ ๋ค์ ๋ช ๋ น์ด๋ฅผ ์คํํ์ธ์:
pip install llama-index
pip install openai
pip install pypdf
pip install python-docx
์ด๋ ๊ฒ ํ๋ฉด LlamaIndex ๋ณธ์ฒด์ ๋ฌธ์ ์ฒ๋ฆฌ์ ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ด ํ๋ฐฉ์ ์ค์น๋ฉ๋๋ค ๐
LlamaIndex๋ ๊ธฐ๋ณธ์ ์ผ๋ก OpenAI์ GPT ๋ชจ๋ธ์ ์ฌ์ฉํด์. ๊ทธ๋์ OpenAI API ํค๊ฐ ํ์ํฉ๋๋ค.
OpenAI ์น์ฌ์ดํธ(platform.openai.com)์์ ๊ณ์ ๋ง๋ค๊ณ API ํค ๋ฐ๊ธ๋ฐ์ผ์๋ฉด ๋ผ์. ์ ๋ฃ๊ธด ํ๋ฐ ํ
์คํธ์ฉ์ผ๋ก๋ ๋ช ๋ฌ๋ฌ๋ฉด ์ถฉ๋ถํฉ๋๋ค ใ
ใ
์ด์ ์ง์ง ์ฝ๋๋ฅผ ์์ฑํด๋ณผ ์๊ฐ์ด์์! ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ํํ๋ถํฐ ์์ํด๋ด ์๋ค ๐
import os
from llama_index import VectorStoreIndex, SimpleDirectoryReader, ServiceContext
from llama_index.llms import OpenAI
# OpenAI API ํค ์ค์
os.environ["OPENAI_API_KEY"] = "your-api-key-here"
# ๋ฌธ์ ๋ก๋ (documents ํด๋์ ์๋ ๋ชจ๋ ํ์ผ)
documents = SimpleDirectoryReader("documents").load_data()
# LLM ์ค์ (GPT-3.5-turbo ์ฌ์ฉ)
llm = OpenAI(model="gpt-3.5-turbo", temperature=0.1)
service_context = ServiceContext.from_defaults(llm=llm)
# ์ธ๋ฑ์ค ์์ฑ
index = VectorStoreIndex.from_documents(
documents,
service_context=service_context
)
# ์ฟผ๋ฆฌ ์์ง ์์ฑ
query_engine = index.as_query_engine()
# ์ง๋ฌธํ๊ธฐ!
response = query_engine.query("์ด ๋ฌธ์์ ์ฃผ์ ๋ด์ฉ์ ๋ญ์ผ?")
print(response)
์ ์ด๊ฒ ๋์ด์์ ใ ใ ใ ์ง์ง ๊ฐ๋จํ์ฃ ? ์ด ์ฝ๋๋ง์ผ๋ก๋ ๋ฌธ์๋ฅผ ์ฝ๊ณ ์ง๋ฌธ์ ๋ต๋ณํ๋ AI ์์คํ ์ด ์์ฑ๋ฉ๋๋ค!
2. VectorStoreIndex: ๋ฌธ์๋ฅผ ๋ฒกํฐ๋ก ๋ณํํด์ ๊ฒ์ ๊ฐ๋ฅํ ์ธ๋ฑ์ค๋ฅผ ๋ง๋ค์ด์. ์ด๊ฒ ํต์ฌ์ด์์ ๐ฏ
3. query_engine: ์ค์ ๋ก ์ง๋ฌธ์ ๋ฐ์์ ๋ต๋ณ์ ์์ฑํ๋ ์์ง์ ๋๋ค. ๊ด๋ จ ๋ฌธ์ ๋ถ๋ถ์ ์ฐพ์์ GPT์๊ฒ ์ ๋ฌํด์ค์.
๊ธฐ๋ณธ ์ฝ๋๋ ๋ดค์ผ๋ ์ด์ ์ข ๋ ์ค์ ์์ ์ธ ์ ์๊ฒ ์ ๊ทธ๋ ์ด๋ํด๋ด ์๋ค! ์ฑ๋ฅ๋ ์ฌ๋ฆฌ๊ณ ๊ธฐ๋ฅ๋ ์ถ๊ฐํ๊ณ ใ ใ
๋ฌธ์๋ฅผ ๋๋ฌด ์๊ฒ ์ชผ๊ฐ๋ฉด ๋งฅ๋ฝ์ด ๋๊ธฐ๊ณ , ๋๋ฌด ํฌ๊ฒ ํ๋ฉด ๊ฒ์ ์ ํ๋๊ฐ ๋จ์ด์ ธ์. ์ ์ ํ ๋ฐธ๋ฐ์ค๊ฐ ์ค์ํฉ๋๋ค!
from llama_index.node_parser import SimpleNodeParser
# ๋
ธ๋ ํ์ ์ค์
node_parser = SimpleNodeParser.from_defaults(
chunk_size=1024, # ์ฒญํฌ ํฌ๊ธฐ (ํ ํฐ ๋จ์)
chunk_overlap=20 # ์ฒญํฌ ๊ฐ ๊ฒน์นจ (๋งฅ๋ฝ ์ ์ง)
)
service_context = ServiceContext.from_defaults(
llm=llm,
node_parser=node_parser
)
chunk_size๋ ๋ณดํต 512~2048 ์ฌ์ด๊ฐ ์ ๋นํด์. ๋ฌธ์ ํน์ฑ์ ๋ฐ๋ผ ์กฐ์ ํ๋ฉด ๋ฉ๋๋ค ๐
๊ธฐ๋ณธ OpenAI ์๋ฒ ๋ฉ ๋ง๊ณ ๋ค๋ฅธ ๋ชจ๋ธ๋ ์ฌ์ฉํ ์ ์์ด์. ๋น์ฉ ์ ๊ฐ์ด๋ ์ฑ๋ฅ ํฅ์์ ์ํด!
from llama_index.embeddings import HuggingFaceEmbedding
# ํ๊ตญ์ด์ ๊ฐํ ์๋ฒ ๋ฉ ๋ชจ๋ธ ์ฌ์ฉ
embed_model = HuggingFaceEmbedding(
model_name="jhgan/ko-sroberta-multitask"
)
service_context = ServiceContext.from_defaults(
llm=llm,
embed_model=embed_model
)
ํ๊ตญ์ด ๋ฌธ์ ๋ค๋ฃฐ ๋๋ ํ๊ตญ์ด ํนํ ๋ชจ๋ธ ์ฐ๋ ๊ฒ ํจ์ฌ ์ข์์! ์ ํ๋๊ฐ ํ ์ฌ๋ผ๊ฐ๋๋ค ๐
๋ฌธ์์ ๋ฉํ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๋ฉด ๊ฒ์ ์ ํ๋๊ฐ ๋ ์ฌ๋ผ๊ฐ์. ๋ ์ง, ์นดํ ๊ณ ๋ฆฌ, ์์ฑ์ ๊ฐ์ ์ ๋ณด๋ค์ด์!
from llama_index import Document
# ๋ฉํ๋ฐ์ดํฐ์ ํจ๊ป ๋ฌธ์ ์์ฑ
documents = [
Document(
text="์ ํ A์ ๊ฐ๊ฒฉ์ 50,000์์
๋๋ค.",
metadata={
"category": "๊ฐ๊ฒฉ์ ๋ณด",
"product": "์ ํA",
"date": "2024-01-15"
}
),
Document(
text="์ ํ A๋ ํ๋์๊ณผ ๋นจ๊ฐ์์ด ์์ต๋๋ค.",
metadata={
"category": "์ํ์ ๋ณด",
"product": "์ ํA",
"date": "2024-01-15"
}
)
]
index = VectorStoreIndex.from_documents(documents)
# ๋ฉํ๋ฐ์ดํฐ ํํฐ๋ง๊ณผ ํจ๊ป ๊ฒ์
from llama_index.vector_stores import MetadataFilters, ExactMatchFilter
filters = MetadataFilters(
filters=[ExactMatchFilter(key="category", value="๊ฐ๊ฒฉ์ ๋ณด")]
)
query_engine = index.as_query_engine(filters=filters)
response = query_engine.query("์ ํ A ๊ฐ๊ฒฉ ์๋ ค์ค")
์ด๋ ๊ฒ ํ๋ฉด ํน์ ์นดํ ๊ณ ๋ฆฌ ๋ฌธ์๋ง ๊ฒ์ํ ์ ์์ด์ ๋ต๋ณ ์ ํ๋๊ฐ ํจ์ฌ ๋์์ง๋๋ค! ์ค๋ฌด์์ ์ง์ง ์ ์ฉํด์ ๐ฏ
๋งค๋ฒ ๋ฌธ์ ์ธ๋ฑ์ฑํ๋ฉด ์๊ฐ๋ ์ค๋ ๊ฑธ๋ฆฌ๊ณ API ๋น์ฉ๋ ๋ง์ด ๋๊ฐ์. ํ ๋ฒ ๋ง๋ ์ธ๋ฑ์ค๋ ์ ์ฅํด๋๋ค๊ฐ ์ฌ์ฌ์ฉํ๋ ๊ฒ ์ข์ต๋๋ค!
# ์ธ๋ฑ์ค๋ฅผ ๋์คํฌ์ ์ ์ฅ
index.storage_context.persist(persist_dir="./storage")
print("์ธ๋ฑ์ค ์ ์ฅ ์๋ฃ! โ
")
์ด๋ ๊ฒ ํ๋ฉด storage ํด๋์ ์ธ๋ฑ์ค๊ฐ ์ ์ฅ๋ฉ๋๋ค. ๋ค์์ ๋ค์ ์ธ ์ ์์ด์!
from llama_index import StorageContext, load_index_from_storage
# ์ ์ฅ๋ ์ธ๋ฑ์ค ๋ก๋
storage_context = StorageContext.from_defaults(
persist_dir="./storage"
)
index = load_index_from_storage(storage_context)
# ๋ฐ๋ก ์ฌ์ฉ ๊ฐ๋ฅ!
query_engine = index.as_query_engine()
response = query_engine.query("์ง๋ฌธ ๋ด์ฉ")
๋ก๋ฉ ์๋๊ฐ ์์ฒญ ๋น ๋ฅด์ฃ ? ๋ช ์ด๋ฉด ๋๋์ ใ ใ ใ ์ด๊ฒ ์ง์ง ์ค์ ํ์ ๋๋ค ๐ฏ
์ด์ ๋ฐฐ์ด ๊ฑธ ๋ค ํฉ์ณ์ ์ค์ ๋ก ์ธ ์ ์๋ ์์คํ ์ ๋ง๋ค์ด๋ด ์๋ค! ํ์ฌ ๋งค๋ด์ผ Q&A ๋ด์ ๋ง๋ค์ด๋ณผ๊ฒ์ ๐ค
import os
from llama_index import (
VectorStoreIndex,
SimpleDirectoryReader,
ServiceContext,
StorageContext,
load_index_from_storage
)
from llama_index.llms import OpenAI
from llama_index.node_parser import SimpleNodeParser
from pathlib import Path
class ManualQABot:
def __init__(self, documents_path, storage_path="./storage"):
self.documents_path = documents_path
self.storage_path = storage_path
self.index = None
self.query_engine = None
# OpenAI API ํค ์ค์
os.environ["OPENAI_API_KEY"] = "your-api-key"
# LLM ๋ฐ ์๋น์ค ์ปจํ
์คํธ ์ค์
llm = OpenAI(model="gpt-3.5-turbo", temperature=0.1)
node_parser = SimpleNodeParser.from_defaults(
chunk_size=1024,
chunk_overlap=20
)
self.service_context = ServiceContext.from_defaults(
llm=llm,
node_parser=node_parser
)
def build_index(self):
"""๋ฌธ์์์ ์ธ๋ฑ์ค ์์ฑ"""
print("๐ ๋ฌธ์ ๋ก๋ฉ ์ค...")
documents = SimpleDirectoryReader(self.documents_path).load_data()
print(f"โ
{len(documents)}๊ฐ ๋ฌธ์ ๋ก๋ ์๋ฃ!")
print("๐จ ์ธ๋ฑ์ค ์์ฑ ์ค...")
self.index = VectorStoreIndex.from_documents(
documents,
service_context=self.service_context
)
print("โ
์ธ๋ฑ์ค ์์ฑ ์๋ฃ!")
# ์ธ๋ฑ์ค ์ ์ฅ
self.index.storage_context.persist(persist_dir=self.storage_path)
print(f"๐พ ์ธ๋ฑ์ค ์ ์ฅ ์๋ฃ: {self.storage_path}")
self.query_engine = self.index.as_query_engine()
def load_index(self):
"""์ ์ฅ๋ ์ธ๋ฑ์ค ๋ก๋"""
if not Path(self.storage_path).exists():
print("โ ์ ์ฅ๋ ์ธ๋ฑ์ค๊ฐ ์์ต๋๋ค. build_index()๋ฅผ ๋จผ์ ์คํํ์ธ์.")
return False
print("๐ ์ ์ฅ๋ ์ธ๋ฑ์ค ๋ก๋ฉ ์ค...")
storage_context = StorageContext.from_defaults(
persist_dir=self.storage_path
)
self.index = load_index_from_storage(
storage_context,
service_context=self.service_context
)
self.query_engine = self.index.as_query_engine()
print("โ
์ธ๋ฑ์ค ๋ก๋ ์๋ฃ!")
return True
def ask(self, question):
"""์ง๋ฌธํ๊ณ ๋ต๋ณ ๋ฐ๊ธฐ"""
if self.query_engine is None:
print("โ ์ธ๋ฑ์ค๊ฐ ๋ก๋๋์ง ์์์ต๋๋ค.")
return None
print(f"\nโ ์ง๋ฌธ: {question}")
print("๐ค ๋ต๋ณ ์์ฑ ์ค...")
response = self.query_engine.query(question)
print(f"\n๐ฌ ๋ต๋ณ:\n{response}\n")
print("-" * 50)
return response
def chat_loop(self):
"""๋ํํ ๋ฃจํ"""
print("\n๐ค ํ์ฌ ๋งค๋ด์ผ Q&A ๋ด์
๋๋ค!")
print("์ง๋ฌธ์ ์
๋ ฅํ์ธ์. (์ข
๋ฃ: 'quit' ๋๋ 'exit')\n")
while True:
question = input("๐ค ์ง๋ฌธ: ").strip()
if question.lower() in ['quit', 'exit', '์ข
๋ฃ']:
print("๐ ๋ด์ ์ข
๋ฃํฉ๋๋ค. ์๋
ํ ๊ฐ์ธ์!")
break
if not question:
continue
self.ask(question)
# ์ฌ์ฉ ์์
if __name__ == "__main__":
# ๋ด ์ด๊ธฐํ
bot = ManualQABot(documents_path="./company_manuals")
# ์ฒ์ ์คํ: ์ธ๋ฑ์ค ์์ฑ
# bot.build_index()
# ์ดํ ์คํ: ์ ์ฅ๋ ์ธ๋ฑ์ค ๋ก๋
if bot.load_index():
# ๋ํํ ๋ชจ๋ ์์
bot.chat_loop()
else:
# ์ธ๋ฑ์ค๊ฐ ์์ผ๋ฉด ์์ฑ
bot.build_index()
bot.chat_loop()
์ ์ด์ ์ง์ง ์์ฑ๋ ์๋ ์์คํ ์ด ๋์ฃ ? ์ด ์ฝ๋๋ ์ค์ ํ์ฌ์์ ๋ฐ๋ก ์ธ ์ ์๋ ์์ค์ด์์! ๐
โข ์ธ๋ฑ์ค ์บ์ฑ: ํ ๋ฒ ๋ง๋ค๋ฉด ๊ณ์ ์ฌ์ฌ์ฉ ๊ฐ๋ฅ
โข ๋ํํ ์ธํฐํ์ด์ค: ์ฌ์ฉ์๊ฐ ํธํ๊ฒ ์ง๋ฌธํ ์ ์์ด์
โข ์๋ฌ ์ฒ๋ฆฌ: ์์ธ ์ํฉ๋ ์ ์ฒ๋ฆฌ๋ฉ๋๋ค
โข ํ์ฅ ๊ฐ๋ฅ: ๊ธฐ๋ฅ ์ถ๊ฐํ๊ธฐ ์ฌ์ด ๊ตฌ์กฐ์์
์ค์ ๋ก ์ด์ํ๋ค ๋ณด๋ฉด ์ฑ๋ฅ ์ด์๊ฐ ์๊ธธ ์ ์์ด์. ํนํ ๋ฌธ์๊ฐ ๋ง๊ฑฐ๋ ์ฌ์ฉ์๊ฐ ๋ง์ ๋์! ๋ช ๊ฐ์ง ์ต์ ํ ๋ฐฉ๋ฒ์ ์๋ ค๋๋ฆด๊ฒ์ โก
๋ฌธ์๊ฐ ๋ง์์ง๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ ๋ฌธ์ ๊ฐ ์๊ธธ ์ ์์ด์. ์ด๋ด ๋๋ ์ ๋ฌธ ๋ฒกํฐ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์ฌ์ฉํ์ธ์!
from llama_index.vector_stores import ChromaVectorStore
from llama_index.storage.storage_context import StorageContext
import chromadb
# Chroma DB ์ด๊ธฐํ
chroma_client = chromadb.PersistentClient(path="./chroma_db")
chroma_collection = chroma_client.get_or_create_collection("company_docs")
# ๋ฒกํฐ ์คํ ์ด ์ค์
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
# ์ธ๋ฑ์ค ์์ฑ (๋ฒกํฐ DB ์ฌ์ฉ)
index = VectorStoreIndex.from_documents(
documents,
storage_context=storage_context
)
Chroma ๋ง๊ณ ๋ Pinecone, Weaviate, Qdrant ๊ฐ์ ๋ฒกํฐ DB๋ค๋ ์์ด์. ๊ฐ๊ฐ ์ฅ๋จ์ ์ด ์์ผ๋ ํ๋ก์ ํธ์ ๋ง๊ฒ ์ ํํ์๋ฉด ๋ฉ๋๋ค!
๋ต๋ณ ์์ฑ ์๋๋ฅผ ๋์ด๋ ๋ฐฉ๋ฒ๋ค์ด์์:
# 1. ๊ฒ์ ๊ฒฐ๊ณผ ๊ฐ์ ์ ํ
query_engine = index.as_query_engine(
similarity_top_k=3 # ์์ 3๊ฐ๋ง ๊ฒ์ (๊ธฐ๋ณธ๊ฐ: 2)
)
# 2. ์คํธ๋ฆฌ๋ฐ ์๋ต ์ฌ์ฉ
query_engine = index.as_query_engine(
streaming=True
)
response = query_engine.query("์ง๋ฌธ")
for text in response.response_gen:
print(text, end="", flush=True)
# 3. ๋ ๋น ๋ฅธ ๋ชจ๋ธ ์ฌ์ฉ
llm = OpenAI(model="gpt-3.5-turbo") # gpt-4๋ณด๋ค ๋น ๋ฆ
์คํธ๋ฆฌ๋ฐ ์๋ต์ ChatGPT์ฒ๋ผ ๊ธ์๊ฐ ํ๋์ฉ ๋ํ๋๋ ํจ๊ณผ์์. ์ฌ์ฉ์ ๊ฒฝํ์ด ํจ์ฌ ์ข์์ง๋๋ค ใ ใ
๊ธฐ๋ณธ Q&A ์์คํ ์ ๋ง๋ค์์ผ๋ ์ด์ ๋ ๋ฉ์ง ๊ธฐ๋ฅ๋ค์ ์ถ๊ฐํด๋ด ์๋ค! ์ค์ ์์ ์ง์ง ์ ์ฉํ ๊ฒ๋ค์ด์์ ๐
๋ฒกํฐ ๊ฒ์๊ณผ ํค์๋ ๊ฒ์์ ํจ๊ป ์ฌ์ฉํ๋ฉด ์ ํ๋๊ฐ ๋ ์ฌ๋ผ๊ฐ์!
from llama_index.retrievers import VectorIndexRetriever, BM25Retriever
from llama_index.query_engine import RetrieverQueryEngine
# ๋ฒกํฐ ๊ฒ์ ๋ฆฌํธ๋ฆฌ๋ฒ
vector_retriever = VectorIndexRetriever(
index=index,
similarity_top_k=5
)
# BM25 ํค์๋ ๊ฒ์ ๋ฆฌํธ๋ฆฌ๋ฒ
bm25_retriever = BM25Retriever.from_defaults(
docstore=index.docstore,
similarity_top_k=5
)
# ํ์ด๋ธ๋ฆฌ๋ ๊ฒ์ ์์ง
from llama_index.retrievers import QueryFusionRetriever
retriever = QueryFusionRetriever(
[vector_retriever, bm25_retriever],
similarity_top_k=5,
num_queries=1
)
query_engine = RetrieverQueryEngine(retriever=retriever)
์ด๋ ๊ฒ ํ๋ฉด ์๋ฏธ์ ์ ์ฌ์ฑ๊ณผ ํค์๋ ๋งค์นญ์ ๋์์ ๊ณ ๋ คํด์ ๋ ์ ํํ ๋ต๋ณ์ ์ค ์ ์์ด์! ํนํ ์ ๋ฌธ ์ฉ์ด๊ฐ ๋ง์ ๋ฌธ์์์ ํจ๊ณผ์ ์ ๋๋ค ๐ฏ
์ด์ ๋ํ ๋ด์ฉ์ ๊ธฐ์ตํ๊ฒ ๋ง๋ค๋ฉด ๋ ์์ฐ์ค๋ฌ์ด ๋ํ๊ฐ ๊ฐ๋ฅํด์!
from llama_index.memory import ChatMemoryBuffer
# ๋ฉ๋ชจ๋ฆฌ ๋ฒํผ ์์ฑ (์ต๊ทผ 10๊ฐ ๋ฉ์์ง ๊ธฐ์ต)
memory = ChatMemoryBuffer.from_defaults(token_limit=3000)
# ์ฑํ
์์ง ์์ฑ
chat_engine = index.as_chat_engine(
chat_mode="context",
memory=memory,
system_prompt=(
"๋น์ ์ ํ์ฌ ๋งค๋ด์ผ ์ ๋ฌธ๊ฐ์
๋๋ค. "
"์น์ ํ๊ณ ์ ํํ๊ฒ ๋ต๋ณํด์ฃผ์ธ์."
)
)
# ๋ํํ๊ธฐ
response1 = chat_engine.chat("์ ํ A์ ๊ฐ๊ฒฉ์ด ์ผ๋ง์ผ?")
print(response1)
# ์ด์ ๋ํ ๊ธฐ์ตํจ!
response2 = chat_engine.chat("๊ทธ๋ผ ํ ์ธ์ ์์ด?") # "์ ํ A"๋ฅผ ๊ธฐ์ต
print(response2)
์ ์ด์ ์ง์ง ChatGPT์ฒ๋ผ ๋ํ๊ฐ ๋์ฃ ? ใ ใ ใ ์ฌ์ฉ์ ๊ฒฝํ์ด ์์ ๋ฌ๋ผ์ง๋๋ค!
๋ต๋ณ์ด ์ด๋ ๋ฌธ์์์ ๋์๋์ง ๋ณด์ฌ์ฃผ๋ฉด ์ ๋ขฐ๋๊ฐ ์ฌ๋ผ๊ฐ์!
query_engine = index.as_query_engine(
response_mode="compact",
verbose=True
)
response = query_engine.query("์ ํ ๊ฐ๊ฒฉ ์๋ ค์ค")
# ๋ต๋ณ ์ถ๋ ฅ
print(f"๋ต๋ณ: {response}\n")
# ์์ค ๋ฌธ์ ์ ๋ณด ์ถ๋ ฅ
print("๐ ์ฐธ๊ณ ๋ฌธ์:")
for i, node in enumerate(response.source_nodes, 1):
print(f"\n{i}. ํ์ผ: {node.metadata.get('file_name', 'Unknown')}")
print(f" ํ์ด์ง: {node.metadata.get('page_label', 'N/A')}")
print(f" ๋ด์ฉ ์ผ๋ถ: {node.text[:100]}...")
print(f" ์ ์ฌ๋ ์ ์: {node.score:.3f}")
์ด๋ ๊ฒ ํ๋ฉด ์ฌ์ฉ์๊ฐ ๋ต๋ณ์ ๋ ์ ๋ขฐํ ์ ์๊ณ , ํ์ํ๋ฉด ์๋ณธ ๋ฌธ์๋ฅผ ์ง์ ํ์ธํ ์๋ ์์ด์! ๊ธฐ์ ์ฉ ์์คํ ์์๋ ํ์ ๊ธฐ๋ฅ์ ๋๋ค ๐
pip install streamlit ์ค์นํ๊ณ ๊ฐ๋จํ ์น UI ๋ง๋ค์ด๋ณด์ธ์. ๋ฒํผ ํด๋ฆญํ๊ณ ์ฑํ ์ฐฝ์์ ๋ํํ๋ ํํ๋ก์ ใ ใ
๊ฐ๋ฐํ๋ค ๋ณด๋ฉด ์๋ฌ๊ฐ ๋๋ ๊ฑด ๋น์ฐํด์! ์์ฃผ ๋์ค๋ ์๋ฌ๋ค๊ณผ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ ๋ฆฌํด๋ดค์ต๋๋ค ๐ง
์ฆ์: OpenAI API ํธ์ถ ์ ํ ์ด๊ณผ
ํด๊ฒฐ:
# ์ฌ์๋ ๋ก์ง ์ถ๊ฐ
from tenacity import retry, stop_after_attempt, wait_exponential
@retry(
stop=stop_after_attempt(3),
wait=wait_exponential(multiplier=1, min=4, max=10)
)
def query_with_retry(query_engine, question):
return query_engine.query(question)
๋๋ ์ ๋ฃ ํ๋์ผ๋ก ์
๊ทธ๋ ์ด๋ํ๊ฑฐ๋, ๋ก์ปฌ ๋ชจ๋ธ ์ฌ์ฉ์ ๊ณ ๋ คํด๋ณด์ธ์!
ํด๊ฒฐ:
โข ์ฒญํฌ ํฌ๊ธฐ๋ฅผ ์ค์ด์ธ์ (1024 โ 512)
โข ๋ฒกํฐ DB ์ฌ์ฉ (Chroma, Pinecone ๋ฑ)
โข ๋ฌธ์๋ฅผ ์ฌ๋ฌ ๊ฐ์ ์ธ๋ฑ์ค๋ก ๋ถํ
โข ๋ฐฐ์น ํฌ๊ธฐ ์กฐ์
ํด๊ฒฐ:
โข ํ๊ตญ์ด ํนํ ์๋ฒ ๋ฉ ๋ชจ๋ธ ์ฌ์ฉ
โข ํ๋กฌํํธ์ "ํ๊ตญ์ด๋ก ๋ต๋ณํด์ฃผ์ธ์" ๋ช ์
โข GPT-4 ๊ฐ์ ๋ ์ข์ ๋ชจ๋ธ ์ฌ์ฉ
โข ๋ฌธ์ ์ ์ฒ๋ฆฌ ์ ์ธ์ฝ๋ฉ ํ์ธ (UTF-8)
verbose=True ์ต์ ์ผ๋ฉด ๋ด๋ถ ๋์ ๊ณผ์ ์ด ๋ค ๋ณด์ฌ์. ๋ญ๊ฐ ๋ฌธ์ ์ธ์ง ํ์ ํ๊ธฐ ์ฌ์์ง๋๋ค!
query_engine = index.as_query_engine(verbose=True)
๊ฐ๋ฐ์ ๋๋ฌ๊ณ ์ด์ ์ค์ ๋ก ์๋น์คํด์ผ์ฃ ? ๋ฐฐํฌ ๋ฐฉ๋ฒ์ ์๋ ค๋๋ฆด๊ฒ์! ๐
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uvicorn
app = FastAPI(title="๋ฌธ์ Q&A API")
# ๋ด ์ด๊ธฐํ (์ ์ญ ๋ณ์)
bot = ManualQABot(documents_path="./documents")
bot.load_index()
class Question(BaseModel):
text: str
class Answer(BaseModel):
answer: str
sources: list = []
@app.post("/ask", response_model=Answer)
async def ask_question(question: Question):
try:
response = bot.ask(question.text)
# ์์ค ์ ๋ณด ์ถ์ถ
sources = []
if hasattr(response, 'source_nodes'):
for node in response.source_nodes:
sources.append({
"file": node.metadata.get('file_name', 'Unknown'),
"score": float(node.score)
})
return Answer(
answer=str(response),
sources=sources
)
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.get("/health")
async def health_check():
return {"status": "healthy"}
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000)
์ด์ http://localhost:8000/ask๋ก POST ์์ฒญ ๋ณด๋ด๋ฉด ๋ต๋ณ์ ๋ฐ์ ์ ์์ด์! Swagger UI๋ ์๋์ผ๋ก ์์ฑ๋ฉ๋๋ค (/docs ์ ์) ๐ก
๋ฐฐํฌ๋ฅผ ์ฝ๊ฒ ํ๋ ค๋ฉด Docker ์ฌ์ฉํ๋ ๊ฒ ์ข์์!
# Dockerfile
FROM python:3.10-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["python", "api.py"]
# requirements.txt
llama-index==0.9.0
openai==1.0.0
fastapi==0.104.0
uvicorn==0.24.0
pypdf==3.17.0
python-docx==1.1.0
# ๋น๋ ๋ฐ ์คํ
docker build -t qa-bot .
docker run -p 8000:8000 -v ./documents:/app/documents qa-bot
์ด์ ์ด๋์๋ ๋๊ฐ์ ํ๊ฒฝ์ผ๋ก ์คํํ ์ ์์ด์! ํด๋ผ์ฐ๋ ๋ฐฐํฌ๋ ์ฌ์์ง๋๋ค โ๏ธ
AWS EC2: ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ฐฉ๋ฒ. ์๋ฒ ํ๋ ๋น๋ ค์ ์ง์ ์ค์น
Google Cloud Run: ์๋ฒ๋ฆฌ์ค๋ก ์๋ ์ค์ผ์ผ๋ง. ์ฌ์ฉํ ๋งํผ๋ง ๊ณผ๊ธ
Heroku: ๊ฐ๋จํ๊ฒ ๋ฐฐํฌ ๊ฐ๋ฅ. ์๊ท๋ชจ ํ๋ก์ ํธ์ ์ข์
Azure Container Instances: ์ปจํ
์ด๋ ๊ธฐ๋ฐ ๋ฐฐํฌ. ๊ด๋ฆฌ ํธํจ
๊ฐ์ธ์ ์ผ๋ก๋ Cloud Run ์ถ์ฒํด์! ์ค์ ๊ฐ๋จํ๊ณ ๋น์ฉ๋ ์ ๋ ดํฉ๋๋ค ใ
ใ
- โ API ํค๋ ํ๊ฒฝ ๋ณ์๋ก ๊ด๋ฆฌ
- โ HTTPS ์ฌ์ฉ (SSL ์ธ์ฆ์ ์ ์ฉ)
- โ Rate Limiting ์ค์ (๋จ์ฉ ๋ฐฉ์ง)
- โ ์ธ์ฆ/์ธ๊ฐ ์์คํ ๊ตฌํ
- โ ๋ก๊ทธ ๋ชจ๋ํฐ๋ง ์ค์
- โ ์ ๊ธฐ์ ์ธ ๋ณด์ ์ ๋ฐ์ดํธ
OpenAI API ์ฐ๋ค ๋ณด๋ฉด ๋น์ฉ์ด ์๊ฐ๋ณด๋ค ๋ง์ด ๋์ฌ ์ ์์ด์. ๋๋ํ๊ฒ ์ ์ฝํ๋ ๋ฐฉ๋ฒ๋ค์ ์๋ ค๋๋ฆด๊ฒ์! ๐ธ
์ฟผ๋ฆฌ ๋น์ฉ: ์ง๋ฌธํ ๋๋ง๋ค ๋ฐ์ (GPT ํธ์ถ)
ํ ํฐ ์: ์ ๋ ฅ + ์ถ๋ ฅ ํ ํฐ ํฉ๊ณ๋ก ๊ณ์ฐ
GPT-3.5-turbo: $0.0015 / 1K tokens (์ ๋ ฅ), $0.002 / 1K tokens (์ถ๋ ฅ)
GPT-4: ์ฝ 20๋ฐฐ ๋ ๋น์ (ํ์ง๋ง ํ์ง์ ๋ ์ข์)
from functools import lru_cache
import hashlib
class CachedQABot:
def __init__(self):
self.cache = {}
def get_cache_key(self, question):
return hashlib.md5(question.encode()).hexdigest()
def ask(self, question):
cache_key = self.get_cache_key(question)
# ์บ์์ ์์ผ๋ฉด ๋ฐ๋ก ๋ฐํ
if cache_key in self.cache:
print("๐พ ์บ์์์ ๋ต๋ณ ๊ฐ์ ธ์ด!")
return self.cache[cache_key]
# ์์ผ๋ฉด ์๋ก ์์ฑ
response = self.query_engine.query(question)
self.cache[cache_key] = response
return response
๊ฐ์ ์ง๋ฌธ์ด ๋ฐ๋ณต๋๋ฉด API ํธ์ถ ์ ํ๊ณ ์ ์ฅ๋ ๋ต๋ณ์ ์ฌ์ฌ์ฉํด์. ๋น์ฉ์ด ํ ์ค์ด๋ญ๋๋ค! ๐
from llama_index.llms import Ollama
# Ollama๋ก ๋ก์ปฌ LLM ์ฌ์ฉ (๋ฌด๋ฃ!)
llm = Ollama(model="llama2", request_timeout=120.0)
service_context = ServiceContext.from_defaults(
llm=llm,
embed_model="local" # ๋ก์ปฌ ์๋ฒ ๋ฉ ๋ชจ๋ธ
)
Ollama ์ค์นํ๋ฉด Llama 2, Mistral ๊ฐ์ ์คํ์์ค ๋ชจ๋ธ์ ๋ก์ปฌ์์ ๋ฌด๋ฃ๋ก ๋๋ฆด ์ ์์ด์! GPU ์์ผ๋ฉด ์๋๋ ๊ด์ฐฎ์ต๋๋ค ๐ฅ๏ธ
๋ฐฐ์ด ๊ฑธ ํ์ฉํด์ ๋ง๋ค ์ ์๋ ์ฌ๋ฏธ์๋ ํ๋ก์ ํธ๋ค์ ์๊ฐํ ๊ฒ์! ํฌํธํด๋ฆฌ์ค์๋ ์ข๊ณ ์ค์ ๋ก ์ธ๋ชจ๋ ์์ด์ ๐
"๋ด๊ฐ ์ฝ์ ์ฑ ์ค์ ์์ฐ์ฑ ๊ด๋ จ๋ ๋ด์ฉ ์ ๋ฆฌํด์ค" ์ด๋ฐ ์ง๋ฌธ ๊ฐ๋ฅ ใ ใ
ํ์ฉ ๋ฌธ์: PDF ๋ ผ๋ฌธ, ์ ์์ฑ , ๋งํฌ๋ค์ด ๋ ธํธ
์ถ๊ฐ ๊ธฐ๋ฅ: ํ๊ทธ ์์คํ , ๋ ์ง๋ณ ๊ฒ์, ์์ฝ ๊ธฐ๋ฅ
"์ฐ์ฐจ ์ ์ฒญ์ ์ด๋ป๊ฒ ํด?" โ ์ฆ์ ๋ต๋ณ + ๊ด๋ จ ๋ฌธ์ ๋งํฌ
ํ์ฉ ๋ฌธ์: ์ธ์ฌ ๊ท์ , IT ๊ฐ์ด๋, FAQ
์ถ๊ฐ ๊ธฐ๋ฅ: ์ฌ๋/ํ์ฆ ์ฐ๋, ํฐ์ผ ์๋ ์์ฑ
"์ด ์ฑํฐ์ ํต์ฌ ๊ฐ๋ 3๊ฐ์ง๋ง ์๋ ค์ค" ๊ฐ์ ์ง๋ฌธ์ผ๋ก ํจ์จ์ ํ์ต
ํ์ฉ ๋ฌธ์: ๊ต๊ณผ์ PDF, ๊ฐ์ ๋ ธํธ, ์ฐธ๊ณ ์๋ฃ
์ถ๊ฐ ๊ธฐ๋ฅ: ํด์ฆ ์์ฑ, ์์ฝ ๊ธฐ๋ฅ, ์ง๋ ์ถ์
(์ฃผ์: ์ค์ ์ง๋ฃ์๋ ์ ๋ฌธ๊ฐ ๊ฒ์ฆ ํ์)
ํ์ฉ ๋ฌธ์: ์ง๋ฃ ๊ฐ์ด๋๋ผ์ธ, ๋ ผ๋ฌธ, ์ฝ๋ฌผ ์ ๋ณด
์ถ๊ฐ ๊ธฐ๋ฅ: ์ฐธ๊ณ ๋ฌธํ ์๋ ์ธ์ฉ, ์ ๋ขฐ๋ ํ์
"20๋ง์๋ ๋ ธํธ๋ถ ์ถ์ฒํด์ค" โ ์กฐ๊ฑด์ ๋ง๋ ์ํ + ์์ธ ์ค๋ช
ํ์ฉ ๋ฌธ์: ์ํ ์ค๋ช ์, ๋ฆฌ๋ทฐ, ์คํ ์ํธ
์ถ๊ฐ ๊ธฐ๋ฅ: ๊ฐ๊ฒฉ ๋น๊ต, ์ฌ๊ณ ํ์ธ, ๊ตฌ๋งค ๋งํฌ
์ด๋ฐ ํ๋ก์ ํธ๋ค ๋ง๋ค์ด์ ์ฌ๋ฅ๋ท์ ๋ฑ๋กํ๋ฉด ์์ต๋ ๋ผ ์ ์์ด์! ์์ฆ AI ๊ธฐ๋ฐ ์๋น์ค ์์๊ฐ ์์ฒญ ๋ง๊ฑฐ๋ ์ ๐ฐ
LlamaIndex์ ๋ฌธ์ ๊ธฐ๋ฐ Q&A ์์คํ ์ ๊ณ์ ๋ฐ์ ํ๊ณ ์์ด์. ์์ผ๋ก ์ด๋ป๊ฒ ๋ณํ ์ง ์ดํด๋ด ์๋ค! ๐
ํ ์คํธ๋ฟ๋ง ์๋๋ผ ์ด๋ฏธ์ง, ํ, ๊ทธ๋ํ๋ ์ดํดํ๋ ์์คํ ์ผ๋ก ์งํ ์ค์ด์์. GPT-4V ๊ฐ์ ๋น์ ๋ชจ๋ธ๊ณผ ๊ฒฐํฉํ๋ฉด ๊ฐ๋ฅํฉ๋๋ค!
โข ์ค์๊ฐ ์ ๋ฐ์ดํธ:
๋ฌธ์๊ฐ ์์ ๋๋ฉด ์๋์ผ๋ก ์ธ๋ฑ์ค ์ ๋ฐ์ดํธํ๋ ๊ธฐ๋ฅ. ํญ์ ์ต์ ์ ๋ณด ์ ์ง ๊ฐ๋ฅ ใ ใ
โข ๋ ์๊ณ ๋น ๋ฅธ ๋ชจ๋ธ:
Mistral 7B, Phi-2 ๊ฐ์ ์ํ ๋ชจ๋ธ๋ค์ด ์ฑ๋ฅ์ ์ข์ผ๋ฉด์ ๋น ๋ฅด๊ณ ์ ๋ ดํด์ง๊ณ ์์ด์. ๋ก์ปฌ ์คํ๋ ์ฌ์์ง๋๋ค!
โข RAG ๊ณ ๋ํ:
Retrieval-Augmented Generation ๊ธฐ์ ์ด ๊ณ์ ๋ฐ์ ํด์ ๋ ์ ํํ๊ณ ์ ๋ขฐํ ์ ์๋ ๋ต๋ณ ์์ฑ ๊ฐ๋ฅ
โข ์์ด์ ํธ ์์คํ :
๋จ์ Q&A๋ฅผ ๋์ด์ ๋ณต์กํ ์์ ์ ์๋์ผ๋ก ์ํํ๋ AI ์์ด์ ํธ๋ก ์งํ ์ค
โข Hugging Face ์ปค๋ฎค๋ํฐ์์ ์ต์ ๋ชจ๋ธ ํ์
โข Reddit r/MachineLearning, r/LocalLLaMA ๊ตฌ๋
โข ์คํ์์ค ํ๋ก์ ํธ์ ๊ธฐ์ฌํ๋ฉด์ ์ค๋ ฅ ํฅ์
โข ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ์ค์ ๊ฒฝํ ์๊ธฐ!
์ ์ฌ๊ธฐ๊น์ง ์ฝ์ผ์
จ๋ค๋ฉด ์ ๋ง ๋๋จํ์ธ์! ๐๐๐
Python๊ณผ LlamaIndex๋ก ๋ฌธ์ ๊ธฐ๋ฐ Q&A ์์คํ
๋ง๋๋ ๋ฐฉ๋ฒ์ ์ฒ์๋ถํฐ ๋๊น์ง ๋ค๋ค๋ดค์ด์. ๊ธฐ๋ณธ ๊ฐ๋
๋ถํฐ ์์ํด์ ์ค์ ๋ฐฐํฌ, ์ต์ ํ, ๊ณ ๊ธ ๊ธฐ๋ฅ๊น์ง ์ ๋ง ๋ง์ ๋ด์ฉ์ ๋ด์๋ค์ ใ
ใ
์ฒ์์๋ ๋ณต์กํด ๋ณด์ผ ์ ์์ง๋ง, ํ๋์ฉ ๋ฐ๋ผํ๋ค ๋ณด๋ฉด ์๊ฐ๋ณด๋ค ์ด๋ ต์ง ์์์! ์ค์ํ ๊ฑด ์ง์ ํด๋ณด๋ ๊ฒ์
๋๋ค. ์์ ํ๋ก์ ํธ๋ถํฐ ์์ํด์ ์ ์ ๊ธฐ๋ฅ์ ์ถ๊ฐํด๋๊ฐ์ธ์ ๐
์ด ๊ธฐ์ ์ ์ ๋ง ๋ค์ํ ๋ถ์ผ์ ์ ์ฉํ ์ ์์ด์. ํ์ฌ ์
๋ฌด ์๋ํ, ๊ณ ๊ฐ ์๋น์ค, ๊ต์ก, ์๋ฃ, ๋ฒ๋ฅ ๋ฑ๋ฑ... ๊ฐ๋ฅ์ฑ์ ๋ฌด๊ถ๋ฌด์งํฉ๋๋ค! ๐ก
ํน์ ๋งํ๋ ๋ถ๋ถ์ด ์๊ฑฐ๋ ๋ ๋ฐฐ์ฐ๊ณ ์ถ์ผ์๋ค๋ฉด ์ฌ๋ฅ๋ท์์ ๊ด๋ จ ์ ๋ฌธ๊ฐ๋ค์ ์ฐพ์๋ณด์ธ์. ์ค์ ๊ฒฝํ์ด ํ๋ถํ ๋ถ๋คํํ
๋ฐฐ์ฐ๋ฉด ํจ์ฌ ๋น ๋ฅด๊ฒ ์ฑ์ฅํ ์ ์์ต๋๋ค ๐
์ฌ๋ฌ๋ถ๋ ๋ฉ์ง AI ์์คํ
๋ง๋ค์ด์ ์ธ์์ ๋ ํธ๋ฆฌํ๊ฒ ๋ง๋ค์ด๋ณด์ธ์! ํ์ดํ
์
๋๋ค ๐ฅ๐ฅ๐ฅ
๐ ํต์ฌ ์์ฝ ๐
โ
LlamaIndex๋ ๋ฌธ์ ๊ธฐ๋ฐ AI ์์คํ
๊ตฌ์ถ์ ์ฝ๊ฒ ๋ง๋ค์ด์ค์
โ
๊ธฐ๋ณธ Q&A ์์คํ
์ ๋ช ์ค์ ์ฝ๋๋ก ๊ตฌํ ๊ฐ๋ฅ
โ
์ฒญํฌ ํฌ๊ธฐ, ์๋ฒ ๋ฉ ๋ชจ๋ธ, ๋ฒกํฐ DB ๋ฑ์ผ๋ก ์ต์ ํ
โ
ํ์ด๋ธ๋ฆฌ๋ ๊ฒ์, ๋ํ ๊ธฐ๋ก, ์์ค ์ถ์ ๋ฑ ๊ณ ๊ธ ๊ธฐ๋ฅ ์ถ๊ฐ ๊ฐ๋ฅ
โ
FastAPI + Docker๋ก ์ค์ ๋ฐฐํฌ
โ
์บ์ฑ๊ณผ ๋ก์ปฌ ๋ชจ๋ธ๋ก ๋น์ฉ ์ ๊ฐ
โ
๋ค์ํ ์ค์ ํ๋ก์ ํธ์ ํ์ฉ ๊ฐ๋ฅ
โ
๊ณ์ ๋ฐ์ ํ๋ ๋ถ์ผ๋๊น ๊พธ์คํ ๊ณต๋ถํ์ธ์!
ํ๋ณตํ ์ฝ๋ฉ ๋์ธ์! ๐๐ปโจ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.