์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿค–โ›“๏ธ ํŒŒ์ด์ฌ๊ณผ ๋žญ์ฒด์ธ์œผ๋กœ AI ๋ธ”๋ก์ฒด์ธ ํ•ด์„ ์ฑ—๋ด‡ ๋งŒ๋“ค๊ธฐ

๐Ÿค–โ›“๏ธ ํŒŒ์ด์ฌ๊ณผ ๋žญ์ฒด์ธ์œผ๋กœ AI ๋ธ”๋ก์ฒด์ธ ํ•ด์„ ์ฑ—๋ด‡ ๋งŒ๋“ค๊ธฐ

๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ๋ฅผ ๋˜‘๋˜‘ํ•˜๊ฒŒ ๋ถ„์„ํ•˜๋Š” AI ์ฑ—๋ด‡, ์ง์ ‘ ๋งŒ๋“ค์–ด๋ณด์ž! ๐Ÿš€

Python + LangChain + Blockchain AI Chatbot Architecture AI ๐Ÿ”—

์•ˆ๋…•, ์นœ๊ตฌ! ๐Ÿ‘‹ ์š”์ฆ˜ ๋ธ”๋ก์ฒด์ธ์ด๋ž‘ AI๊ฐ€ ๋Œ€์„ธ์ž–์•„? ๊ทผ๋ฐ ์ด ๋‘˜์„ ํ•ฉ์น˜๋ฉด ๋ญ”๊ฐ€ ์—„์ฒญ๋‚œ ๊ฑธ ๋งŒ๋“ค ์ˆ˜ ์žˆ์„ ๊ฒƒ ๊ฐ™์ง€ ์•Š์•„? ์˜ค๋Š˜์€ ๋ฐ”๋กœ ๊ทธ ์ด์•ผ๊ธฐ๋ฅผ ํ•ด๋ณด๋ ค๊ณ  ํ•ด. ๐ŸŽฏ

๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ๋Š” ์†”์งํžˆ ๋งํ•˜๋ฉด ์ข€ ๋ณต์žกํ•ด. ํŠธ๋žœ์žญ์…˜ ํ•ด์‹œ, ์Šค๋งˆํŠธ ์ปจํŠธ๋ž™ํŠธ ์ฃผ์†Œ, ๊ฐ€์Šค๋น„... ์ด๋Ÿฐ ๊ฑฐ ๋ณด๋ฉด ๋จธ๋ฆฌ๊ฐ€ ์ง€๋ˆ์ง€๋ˆํ•˜์ž–์•„? ๊ทธ๋Ÿฐ๋ฐ ๋งŒ์•ฝ ์ด ๋ชจ๋“  ๊ฑธ ์ž์—ฐ์–ด๋กœ ๋ฌผ์–ด๋ณด๋ฉด AI๊ฐ€ ์ฒ™์ฒ™ ๋Œ€๋‹ตํ•ด์ฃผ๋Š” ์ฑ—๋ด‡์ด ์žˆ๋‹ค๋ฉด? ๐Ÿค”

๋ฐ”๋กœ ๊ทธ๊ฑธ ๋งŒ๋“ค์–ด๋ณผ ๊ฑฐ์•ผ! ํŒŒ์ด์ฌ๊ณผ ๋žญ์ฒด์ธ(LangChain)์„ ํ™œ์šฉํ•ด์„œ ๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ๋ฅผ ํ•ด์„ํ•˜๋Š” ๋˜‘๋˜‘ํ•œ AI ์ฑ—๋ด‡์„ ์ง์ ‘ ๊ตฌ์ถ•ํ•ด๋ณด์ž๊ณ . ์ฝ”๋”ฉ ๊ฒฝํ—˜์ด ์ข€ ์žˆ๋‹ค๋ฉด ์ถฉ๋ถ„ํžˆ ๋”ฐ๋ผ์˜ฌ ์ˆ˜ ์žˆ์„ ๊ฑฐ์•ผ!


๐ŸŽช ์™œ ๋ธ”๋ก์ฒด์ธ ํ•ด์„ ์ฑ—๋ด‡์ด ํ•„์š”ํ• ๊นŒ?

๋จผ์ € ์ด ํ”„๋กœ์ ํŠธ๊ฐ€ ์™œ ์˜๋ฏธ ์žˆ๋Š”์ง€๋ถ€ํ„ฐ ์ด์•ผ๊ธฐํ•ด๋ณผ๊ฒŒ. ๐Ÿ’ก

๋ธ”๋ก์ฒด์ธ ์ƒํƒœ๊ณ„๋Š” ์—„์ฒญ๋‚˜๊ฒŒ ๋น ๋ฅด๊ฒŒ ์„ฑ์žฅํ•˜๊ณ  ์žˆ์–ด. ์ด๋”๋ฆฌ์›€, ๋น„ํŠธ์ฝ”์ธ, ์†”๋ผ๋‚˜, ํด๋ฆฌ๊ณค... ์ˆ˜๋งŽ์€ ์ฒด์ธ๋“ค์ด ์žˆ๊ณ , ๋งค์ผ ์ˆ˜๋ฐฑ๋งŒ ๊ฑด์˜ ํŠธ๋žœ์žญ์…˜์ด ๋ฐœ์ƒํ•˜์ง€. ๊ทธ๋Ÿฐ๋ฐ ๋ฌธ์ œ๋Š” ์ด ๋ฐ์ดํ„ฐ๋“ค์ด ์ผ๋ฐ˜ ์‚ฌ์šฉ์ž๋“ค์—๊ฒŒ๋Š” ๋„ˆ๋ฌด ์–ด๋ ต๋‹ค๋Š” ๊ฑฐ์•ผ.

๐Ÿ” ์‹ค์ œ ์‚ฌ์šฉ ์‚ฌ๋ก€๋“ค 1. ํˆฌ์ž์ž๋“ค: "์ด ์ง€๊ฐ‘ ์ฃผ์†Œ๊ฐ€ ์ตœ๊ทผ์— ์–ด๋–ค ํ† ํฐ์„ ์ƒ€๋Š”์ง€ ์•Œ๋ ค์ค˜"
2. ๊ฐœ๋ฐœ์ž๋“ค: "์ด ์Šค๋งˆํŠธ ์ปจํŠธ๋ž™ํŠธ์˜ ํ•จ์ˆ˜ ํ˜ธ์ถœ ํŒจํ„ด์„ ๋ถ„์„ํ•ด์ค˜"
3. ๊ฐ์‚ฌ๊ด€๋“ค: "์˜์‹ฌ์Šค๋Ÿฌ์šด ํŠธ๋žœ์žญ์…˜ ํŒจํ„ด์„ ์ฐพ์•„์ค˜"
4. ์ผ๋ฐ˜ ์‚ฌ์šฉ์ž: "๋‚ด NFT ๊ฑฐ๋ž˜ ๋‚ด์—ญ์„ ์‰ฝ๊ฒŒ ์„ค๋ช…ํ•ด์ค˜"

์ด๋Ÿฐ ์งˆ๋ฌธ๋“ค์— ๋Œ€๋‹ตํ•˜๋ ค๋ฉด ๋ณดํ†ต ๋ธ”๋ก ์ต์Šคํ”Œ๋กœ๋Ÿฌ๋ฅผ ๋’ค์ง€๊ณ , ๋ณต์žกํ•œ ์ฟผ๋ฆฌ๋ฅผ ์ž‘์„ฑํ•˜๊ณ , ๋ฐ์ดํ„ฐ๋ฅผ ๋ถ„์„ํ•ด์•ผ ํ•ด. ํ•˜์ง€๋งŒ AI ์ฑ—๋ด‡์ด ์žˆ๋‹ค๋ฉด? ๊ทธ๋ƒฅ ๋ฌผ์–ด๋ณด๊ธฐ๋งŒ ํ•˜๋ฉด ๋ผ! โœจ


๐Ÿ› ๏ธ ํ•„์š”ํ•œ ๋„๊ตฌ๋“ค๊ณผ ๊ธฐ์ˆ  ์Šคํƒ

์ž, ์ด์ œ ๋ณธ๊ฒฉ์ ์œผ๋กœ ์‹œ์ž‘ํ•ด๋ณผ๊นŒ? ๋จผ์ € ์šฐ๋ฆฌ๊ฐ€ ์‚ฌ์šฉํ•  ๋„๊ตฌ๋“ค์„ ์‚ดํŽด๋ณด์ž. ๐Ÿงฐ

๐Ÿ Python ์šฐ๋ฆฌ์˜ ๋ฉ”์ธ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด. ๋ฒ„์ „ 3.8 ์ด์ƒ์„ ์ถ”์ฒœํ•ด. ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ์™€ AI ๋ชจ๋ธ ์—ฐ๋™์— ์ตœ์ ํ™”๋˜์–ด ์žˆ์ง€.
๐Ÿฆœ LangChain LLM(๋Œ€๊ทœ๋ชจ ์–ธ์–ด ๋ชจ๋ธ)์„ ์‰ฝ๊ฒŒ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•ด์ฃผ๋Š” ํ”„๋ ˆ์ž„์›Œํฌ. ์ฒด์ธ ๊ตฌ์„ฑ, ๋ฉ”๋ชจ๋ฆฌ ๊ด€๋ฆฌ, ์—์ด์ „ํŠธ ์ƒ์„ฑ ๋“ฑ์„ ๊ฐ„ํŽธํ•˜๊ฒŒ ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ์–ด.
โ›“๏ธ Web3.py ์ด๋”๋ฆฌ์›€ ๋ธ”๋ก์ฒด์ธ๊ณผ ์ƒํ˜ธ์ž‘์šฉํ•˜๊ธฐ ์œ„ํ•œ ํŒŒ์ด์ฌ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ. ํŠธ๋žœ์žญ์…˜ ์กฐํšŒ, ์Šค๋งˆํŠธ ์ปจํŠธ๋ž™ํŠธ ํ˜ธ์ถœ ๋“ฑ์„ ์ฒ˜๋ฆฌํ•ด.
๐Ÿค– OpenAI API GPT ๋ชจ๋ธ์„ ์‚ฌ์šฉํ•˜๊ธฐ ์œ„ํ•œ API. ์ž์—ฐ์–ด ์ดํ•ด์™€ ์ƒ์„ฑ์˜ ํ•ต์‹ฌ์ด์ง€. Claude๋‚˜ ๋‹ค๋ฅธ LLM๋„ ์‚ฌ์šฉ ๊ฐ€๋Šฅํ•ด.
๐Ÿ’ก Tip: ๋งŒ์•ฝ ๋ธ”๋ก์ฒด์ธ ๊ฐœ๋ฐœ์ด ์ฒ˜์Œ์ด๋ผ๋ฉด ์žฌ๋Šฅ๋„ท์—์„œ ๋ธ”๋ก์ฒด์ธ ์ „๋ฌธ๊ฐ€๋“ค์˜ ์กฐ์–ธ์„ ๊ตฌํ•ด๋ณด๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ. ์‹ค์ „ ๊ฒฝํ—˜์ด ์žˆ๋Š” ๊ฐœ๋ฐœ์ž๋“ค์˜ ๋ฉ˜ํ† ๋ง์€ ์ •๋ง ํฐ ๋„์›€์ด ๋˜๊ฑฐ๋“ !

์ถ”๊ฐ€๋กœ ํ•„์š”ํ•œ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋“ค๋„ ์žˆ์–ด:

โ€ข requests: API ํ˜ธ์ถœ์šฉ
โ€ข pandas: ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ์šฉ
โ€ข python-dotenv: ํ™˜๊ฒฝ ๋ณ€์ˆ˜ ๊ด€๋ฆฌ์šฉ
โ€ข chromadb: ๋ฒกํ„ฐ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค์šฉ (์„ ํƒ์‚ฌํ•ญ)


๐Ÿ“ฆ ํ™˜๊ฒฝ ์„ค์ •ํ•˜๊ธฐ

์ž, ์ด์ œ ์‹ค์ œ๋กœ ์†์„ ๋”๋Ÿฝํ˜€๋ณผ ์‹œ๊ฐ„์ด์•ผ! ๐Ÿ’ป ๋จผ์ € ๊ฐœ๋ฐœ ํ™˜๊ฒฝ์„ ์„ธํŒ…ํ•ด๋ณด์ž.

Step 1: ๊ฐ€์ƒํ™˜๊ฒฝ ์ƒ์„ฑ

ํ”„๋กœ์ ํŠธ ํด๋”๋ฅผ ๋งŒ๋“ค๊ณ  ๊ฐ€์ƒํ™˜๊ฒฝ์„ ์„ค์ •ํ•˜์ž. ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ํŒจํ‚ค์ง€ ์ถฉ๋Œ์„ ๋ฐฉ์ง€ํ•  ์ˆ˜ ์žˆ์–ด.
mkdir blockchain-chatbot
cd blockchain-chatbot
python -m venv venv

# Windows
venv\Scripts\activate

# Mac/Linux
source venv/bin/activate
Step 2: ํ•„์ˆ˜ ํŒจํ‚ค์ง€ ์„ค์น˜

์ด์ œ ํ•„์š”ํ•œ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋“ค์„ ์„ค์น˜ํ•ด๋ณด์ž.
pip install langchain openai web3 python-dotenv requests pandas chromadb
Step 3: API ํ‚ค ์„ค์ •

ํ”„๋กœ์ ํŠธ ๋ฃจํŠธ์— .env ํŒŒ์ผ์„ ๋งŒ๋“ค์–ด์„œ API ํ‚ค๋“ค์„ ์ €์žฅํ•˜์ž.
# .env ํŒŒ์ผ
OPENAI_API_KEY=your_openai_api_key_here
INFURA_API_KEY=your_infura_api_key_here
ETHERSCAN_API_KEY=your_etherscan_api_key_here
โš ๏ธ ์ฃผ์˜: .env ํŒŒ์ผ์€ ์ ˆ๋Œ€ ๊นƒํ—ˆ๋ธŒ์— ์˜ฌ๋ฆฌ๋ฉด ์•ˆ ๋ผ! .gitignore์— ๊ผญ ์ถ”๊ฐ€ํ•ด์ค˜์•ผ ํ•ด. API ํ‚ค๊ฐ€ ๋…ธ์ถœ๋˜๋ฉด ํฐ์ผ๋‚˜๊ฑฐ๋“ !

API ํ‚ค๋ฅผ ์–ด๋””์„œ ๋ฐ›๋ƒ๊ณ ? ๐Ÿ”‘

โ€ข OpenAI: platform.openai.com์—์„œ ๊ณ„์ • ๋งŒ๋“ค๊ณ  ๋ฐœ๊ธ‰
โ€ข Infura: infura.io์—์„œ ๋ฌด๋ฃŒ ๊ณ„์ • ์ƒ์„ฑ (์ด๋”๋ฆฌ์›€ ๋…ธ๋“œ ์ ‘๊ทผ์šฉ)
โ€ข Etherscan: etherscan.io์—์„œ ๋ฌด๋ฃŒ API ํ‚ค ๋ฐœ๊ธ‰ (ํŠธ๋žœ์žญ์…˜ ์กฐํšŒ์šฉ)


๐Ÿ—๏ธ ๊ธฐ๋ณธ ์•„ํ‚คํ…์ฒ˜ ์„ค๊ณ„

์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•˜๊ธฐ ์ „์— ์ „์ฒด ์‹œ์Šคํ…œ ๊ตฌ์กฐ๋ฅผ ์ดํ•ดํ•˜๋Š” ๊ฒŒ ์ค‘์š”ํ•ด. ์šฐ๋ฆฌ ์ฑ—๋ด‡์€ ํฌ๊ฒŒ 4๊ฐœ์˜ ๋ ˆ์ด์–ด๋กœ ๊ตฌ์„ฑ๋  ๊ฑฐ์•ผ. ๐ŸŽจ

User Interface Layer LangChain Agent Layer Blockchain Data Layer External APIs Layer
๐ŸŽฏ ๊ฐ ๋ ˆ์ด์–ด์˜ ์—ญํ•  1. User Interface Layer: ์‚ฌ์šฉ์ž์˜ ์งˆ๋ฌธ์„ ๋ฐ›๊ณ  ๋‹ต๋ณ€์„ ํ‘œ์‹œํ•˜๋Š” ์ธํ„ฐํŽ˜์ด์Šค
2. LangChain Agent Layer: ์งˆ๋ฌธ์„ ์ดํ•ดํ•˜๊ณ  ์ ์ ˆํ•œ ๋„๊ตฌ๋ฅผ ์„ ํƒํ•ด์„œ ์‹คํ–‰
3. Blockchain Data Layer: ๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ๋ฅผ ์กฐํšŒํ•˜๊ณ  ์ฒ˜๋ฆฌ
4. External APIs Layer: Infura, Etherscan ๋“ฑ ์™ธ๋ถ€ API์™€ ํ†ต์‹ 

์ด ๊ตฌ์กฐ์˜ ์žฅ์ ์€ ๋ญ๋ƒ๊ณ ? ๐ŸŒŸ

โ€ข ๋ชจ๋“ˆํ™”: ๊ฐ ๋ ˆ์ด์–ด๊ฐ€ ๋…๋ฆฝ์ ์ด๋ผ ์œ ์ง€๋ณด์ˆ˜๊ฐ€ ์‰ฌ์›Œ
โ€ข ํ™•์žฅ์„ฑ: ์ƒˆ๋กœ์šด ๋ธ”๋ก์ฒด์ธ์ด๋‚˜ ๊ธฐ๋Šฅ ์ถ”๊ฐ€๊ฐ€ ๊ฐ„ํŽธํ•ด
โ€ข ํ…Œ์ŠคํŠธ ์šฉ์ด์„ฑ: ๊ฐ ๋ ˆ์ด์–ด๋ฅผ ๋…๋ฆฝ์ ์œผ๋กœ ํ…Œ์ŠคํŠธํ•  ์ˆ˜ ์žˆ์–ด
โ€ข ์žฌ์‚ฌ์šฉ์„ฑ: ๋‹ค๋ฅธ ํ”„๋กœ์ ํŠธ์—์„œ๋„ ํŠน์ • ๋ ˆ์ด์–ด๋ฅผ ์žฌํ™œ์šฉ ๊ฐ€๋Šฅํ•ด


๐Ÿ”— ๋ธ”๋ก์ฒด์ธ ์—ฐ๊ฒฐ ๋ชจ๋“ˆ ๋งŒ๋“ค๊ธฐ

์ž, ์ด์ œ ์‹ค์ œ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•ด๋ณด์ž! ๋จผ์ € ๋ธ”๋ก์ฒด์ธ๊ณผ ์—ฐ๊ฒฐํ•˜๋Š” ๊ธฐ๋ณธ ๋ชจ๋“ˆ๋ถ€ํ„ฐ ๋งŒ๋“ค์–ด๋ณผ๊ฒŒ. โšก

blockchain_connector.py ํŒŒ์ผ์„ ๋งŒ๋“ค์–ด์„œ ๋‹ค์Œ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•ด๋ณด์ž:

from web3 import Web3
from typing import Dict, List, Optional
import os
from dotenv import load_dotenv

load_dotenv()

class BlockchainConnector:
    """๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ ์กฐํšŒ๋ฅผ ์œ„ํ•œ ์ปค๋„ฅํ„ฐ ํด๋ž˜์Šค"""
    
    def __init__(self, network: str = "mainnet"):
        """
        Args:
            network: ์—ฐ๊ฒฐํ•  ๋„คํŠธ์›Œํฌ (mainnet, goerli, sepolia ๋“ฑ)
        """
        self.infura_key = os.getenv("INFURA_API_KEY")
        self.network = network
        
        # Infura ์—”๋“œํฌ์ธํŠธ ์„ค์ •
        infura_url = f"https://{network}.infura.io/v3/{self.infura_key}"
        self.w3 = Web3(Web3.HTTPProvider(infura_url))
        
        # ์—ฐ๊ฒฐ ํ™•์ธ
        if not self.w3.is_connected():
            raise ConnectionError(f"Failed to connect to {network}")
        
        print(f"โœ… Connected to Ethereum {network}")
    
    def get_balance(self, address: str) -> Dict:
        """์ง€๊ฐ‘ ์ฃผ์†Œ์˜ ETH ์ž”์•ก ์กฐํšŒ"""
        try:
            # ์ฃผ์†Œ ์ฒดํฌ์„ฌ ๋ณ€ํ™˜
            checksum_address = Web3.to_checksum_address(address)
            
            # Wei ๋‹จ์œ„๋กœ ์ž”์•ก ์กฐํšŒ
            balance_wei = self.w3.eth.get_balance(checksum_address)
            
            # ETH๋กœ ๋ณ€ํ™˜
            balance_eth = self.w3.from_wei(balance_wei, 'ether')
            
            return {
                "address": address,
                "balance_wei": balance_wei,
                "balance_eth": float(balance_eth),
                "network": self.network
            }
        except Exception as e:
            return {"error": str(e)}
    
    def get_transaction(self, tx_hash: str) -> Dict:
        """ํŠธ๋žœ์žญ์…˜ ์ •๋ณด ์กฐํšŒ"""
        try:
            tx = self.w3.eth.get_transaction(tx_hash)
            receipt = self.w3.eth.get_transaction_receipt(tx_hash)
            
            return {
                "hash": tx_hash,
                "from": tx['from'],
                "to": tx['to'],
                "value_eth": float(self.w3.from_wei(tx['value'], 'ether')),
                "gas_price": tx['gasPrice'],
                "gas_used": receipt['gasUsed'],
                "status": "success" if receipt['status'] == 1 else "failed",
                "block_number": tx['blockNumber']
            }
        except Exception as e:
            return {"error": str(e)}
    
    def get_latest_block(self) -> Dict:
        """์ตœ์‹  ๋ธ”๋ก ์ •๋ณด ์กฐํšŒ"""
        try:
            latest_block = self.w3.eth.get_block('latest')
            
            return {
                "block_number": latest_block['number'],
                "timestamp": latest_block['timestamp'],
                "transactions_count": len(latest_block['transactions']),
                "gas_used": latest_block['gasUsed'],
                "gas_limit": latest_block['gasLimit']
            }
        except Exception as e:
            return {"error": str(e)}
๐Ÿ’ก ์ฝ”๋“œ ์„ค๋ช…: ์ด ํด๋ž˜์Šค๋Š” Web3.py๋ฅผ ์‚ฌ์šฉํ•ด์„œ ์ด๋”๋ฆฌ์›€ ๋ธ”๋ก์ฒด์ธ๊ณผ ํ†ต์‹ ํ•ด. get_balance๋กœ ์ž”์•ก์„ ํ™•์ธํ•˜๊ณ , get_transaction์œผ๋กœ ํŠธ๋žœ์žญ์…˜ ์ •๋ณด๋ฅผ ๊ฐ€์ ธ์˜ค๊ณ , get_latest_block์œผ๋กœ ์ตœ์‹  ๋ธ”๋ก ์ •๋ณด๋ฅผ ์กฐํšŒํ•  ์ˆ˜ ์žˆ์–ด.

์ด์ œ ์ด ์ปค๋„ฅํ„ฐ๋ฅผ ํ…Œ์ŠคํŠธํ•ด๋ณด์ž:

# test_connector.py
from blockchain_connector import BlockchainConnector

# ์ปค๋„ฅํ„ฐ ์ดˆ๊ธฐํ™”
connector = BlockchainConnector(network="mainnet")

# Vitalik Buterin์˜ ์ง€๊ฐ‘ ์ž”์•ก ํ™•์ธ (์˜ˆ์‹œ)
vitalik_address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
balance = connector.get_balance(vitalik_address)
print(f"Balance: {balance['balance_eth']} ETH")

# ์ตœ์‹  ๋ธ”๋ก ์ •๋ณด
latest = connector.get_latest_block()
print(f"Latest block: #{latest['block_number']}")

์‹คํ–‰ํ•˜๋ฉด ์‹ค์‹œ๊ฐ„ ๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ๋ฅผ ๊ฐ€์ ธ์˜ค๋Š” ๊ฑธ ํ™•์ธํ•  ์ˆ˜ ์žˆ์–ด! ๐ŸŽ‰


๐Ÿฆœ LangChain ์—์ด์ „ํŠธ ๊ตฌ์ถ•ํ•˜๊ธฐ

์ด์ œ ์ง„์งœ ํ•ต์‹ฌ์ธ LangChain ์—์ด์ „ํŠธ๋ฅผ ๋งŒ๋“ค์–ด๋ณผ ์ฐจ๋ก€์•ผ. ์ด ์—์ด์ „ํŠธ๊ฐ€ ์‚ฌ์šฉ์ž์˜ ์งˆ๋ฌธ์„ ์ดํ•ดํ•˜๊ณ  ์ ์ ˆํ•œ ๋ธ”๋ก์ฒด์ธ ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•  ๊ฑฐ์•ผ. ๐Ÿง 

LangChain์˜ ๊ฐ•๋ ฅํ•œ ์ ์€ ๋„๊ตฌ(Tools)๋ฅผ ์ •์˜ํ•˜๋ฉด AI๊ฐ€ ์•Œ์•„์„œ ์ ์ ˆํ•œ ๋„๊ตฌ๋ฅผ ์„ ํƒํ•ด์„œ ์‚ฌ์šฉํ•œ๋‹ค๋Š” ๊ฑฐ์•ผ. ๋งˆ์น˜ ์ง„์งœ ๋น„์„œ์ฒ˜๋Ÿผ ๋ง์ด์ง€!

langchain_agent.py ํŒŒ์ผ์„ ๋งŒ๋“ค์–ด๋ณด์ž:

from langchain.agents import Tool, AgentExecutor, create_openai_functions_agent
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.memory import ConversationBufferMemory
from blockchain_connector import BlockchainConnector
import os
from dotenv import load_dotenv

load_dotenv()

class BlockchainChatbot:
    """๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ๋ฅผ ํ•ด์„ํ•˜๋Š” AI ์ฑ—๋ด‡"""
    
    def __init__(self, network: str = "mainnet"):
        # ๋ธ”๋ก์ฒด์ธ ์ปค๋„ฅํ„ฐ ์ดˆ๊ธฐํ™”
        self.connector = BlockchainConnector(network=network)
        
        # OpenAI LLM ์ดˆ๊ธฐํ™”
        self.llm = ChatOpenAI(
            model="gpt-4",
            temperature=0,
            openai_api_key=os.getenv("OPENAI_API_KEY")
        )
        
        # ๋Œ€ํ™” ๋ฉ”๋ชจ๋ฆฌ ์„ค์ •
        self.memory = ConversationBufferMemory(
            memory_key="chat_history",
            return_messages=True
        )
        
        # ๋„๊ตฌ ์ •์˜
        self.tools = self._create_tools()
        
        # ์—์ด์ „ํŠธ ์ƒ์„ฑ
        self.agent = self._create_agent()
    
    def _create_tools(self) -> list:
        """๋ธ”๋ก์ฒด์ธ ์กฐํšŒ ๋„๊ตฌ๋“ค์„ ์ •์˜"""
        
        def get_balance_tool(address: str) -> str:
            """์ง€๊ฐ‘ ์ฃผ์†Œ์˜ ETH ์ž”์•ก์„ ์กฐํšŒํ•ฉ๋‹ˆ๋‹ค."""
            result = self.connector.get_balance(address)
            if "error" in result:
                return f"์˜ค๋ฅ˜ ๋ฐœ์ƒ: {result['error']}"
            return f"์ฃผ์†Œ {address}์˜ ์ž”์•ก์€ {result['balance_eth']:.4f} ETH์ž…๋‹ˆ๋‹ค."
        
        def get_transaction_tool(tx_hash: str) -> str:
            """ํŠธ๋žœ์žญ์…˜ ํ•ด์‹œ๋กœ ๊ฑฐ๋ž˜ ์ •๋ณด๋ฅผ ์กฐํšŒํ•ฉ๋‹ˆ๋‹ค."""
            result = self.connector.get_transaction(tx_hash)
            if "error" in result:
                return f"์˜ค๋ฅ˜ ๋ฐœ์ƒ: {result['error']}"
            
            return f"""
ํŠธ๋žœ์žญ์…˜ ์ •๋ณด:
- ํ•ด์‹œ: {result['hash']}
- ๋ณด๋‚ด๋Š” ์ฃผ์†Œ: {result['from']}
- ๋ฐ›๋Š” ์ฃผ์†Œ: {result['to']}
- ์ „์†ก ๊ธˆ์•ก: {result['value_eth']} ETH
- ์ƒํƒœ: {result['status']}
- ๋ธ”๋ก ๋ฒˆํ˜ธ: {result['block_number']}
- ๊ฐ€์Šค ์‚ฌ์šฉ๋Ÿ‰: {result['gas_used']}
            """
        
        def get_latest_block_tool(dummy: str = "") -> str:
            """์ตœ์‹  ๋ธ”๋ก ์ •๋ณด๋ฅผ ์กฐํšŒํ•ฉ๋‹ˆ๋‹ค."""
            result = self.connector.get_latest_block()
            if "error" in result:
                return f"์˜ค๋ฅ˜ ๋ฐœ์ƒ: {result['error']}"
            
            return f"""
์ตœ์‹  ๋ธ”๋ก ์ •๋ณด:
- ๋ธ”๋ก ๋ฒˆํ˜ธ: #{result['block_number']}
- ํŠธ๋žœ์žญ์…˜ ์ˆ˜: {result['transactions_count']}๊ฐœ
- ๊ฐ€์Šค ์‚ฌ์šฉ๋Ÿ‰: {result['gas_used']}
- ๊ฐ€์Šค ํ•œ๋„: {result['gas_limit']}
            """
        
        # Tool ๊ฐ์ฒด๋กœ ๋ณ€ํ™˜
        tools = [
            Tool(
                name="get_wallet_balance",
                func=get_balance_tool,
                description="์ด๋”๋ฆฌ์›€ ์ง€๊ฐ‘ ์ฃผ์†Œ์˜ ETH ์ž”์•ก์„ ์กฐํšŒํ•  ๋•Œ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ์ž…๋ ฅ: ์ง€๊ฐ‘ ์ฃผ์†Œ (0x๋กœ ์‹œ์ž‘)"
            ),
            Tool(
                name="get_transaction_info",
                func=get_transaction_tool,
                description="ํŠธ๋žœ์žญ์…˜ ํ•ด์‹œ๋กœ ๊ฑฐ๋ž˜ ์ƒ์„ธ ์ •๋ณด๋ฅผ ์กฐํšŒํ•  ๋•Œ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ์ž…๋ ฅ: ํŠธ๋žœ์žญ์…˜ ํ•ด์‹œ (0x๋กœ ์‹œ์ž‘)"
            ),
            Tool(
                name="get_latest_block",
                func=get_latest_block_tool,
                description="์ด๋”๋ฆฌ์›€ ๋„คํŠธ์›Œํฌ์˜ ์ตœ์‹  ๋ธ”๋ก ์ •๋ณด๋ฅผ ์กฐํšŒํ•  ๋•Œ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ์ž…๋ ฅ: ์—†์Œ (๋นˆ ๋ฌธ์ž์—ด)"
            )
        ]
        
        return tools
    
    def _create_agent(self):
        """LangChain ์—์ด์ „ํŠธ ์ƒ์„ฑ"""
        
        # ์‹œ์Šคํ…œ ํ”„๋กฌํ”„ํŠธ ์ •์˜
        system_message = """๋‹น์‹ ์€ ๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ๋ฅผ ๋ถ„์„ํ•˜๊ณ  ํ•ด์„ํ•˜๋Š” ์ „๋ฌธ AI ์–ด์‹œ์Šคํ„ดํŠธ์ž…๋‹ˆ๋‹ค.

์‚ฌ์šฉ์ž์˜ ์งˆ๋ฌธ์„ ์ดํ•ดํ•˜๊ณ  ์ ์ ˆํ•œ ๋„๊ตฌ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ๋ฅผ ์กฐํšŒํ•œ ํ›„, 
๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์นœ์ ˆํ•˜๊ณ  ์ดํ•ดํ•˜๊ธฐ ์‰ฝ๊ฒŒ ์„ค๋ช…ํ•ด์ฃผ์„ธ์š”.

์ฃผ์š” ์—ญํ• :
1. ์ง€๊ฐ‘ ์ฃผ์†Œ, ํŠธ๋žœ์žญ์…˜ ํ•ด์‹œ ๋“ฑ์„ ์ •ํ™•ํžˆ ํŒŒ์•…
2. ์ ์ ˆํ•œ ๋„๊ตฌ๋ฅผ ์„ ํƒํ•˜์—ฌ ๋ฐ์ดํ„ฐ ์กฐํšŒ
3. ์กฐํšŒ๋œ ๋ฐ์ดํ„ฐ๋ฅผ ์ผ๋ฐ˜์ธ๋„ ์ดํ•ดํ•  ์ˆ˜ ์žˆ๊ฒŒ ์„ค๋ช…
4. ํ•„์š”์‹œ ๋ธ”๋ก์ฒด์ธ ์šฉ์–ด๋ฅผ ์‰ฝ๊ฒŒ ํ’€์–ด์„œ ์„ค๋ช…

ํ•ญ์ƒ ์ •ํ™•ํ•˜๊ณ  ์นœ์ ˆํ•˜๊ฒŒ ๋‹ต๋ณ€ํ•ด์ฃผ์„ธ์š”."""

        prompt = ChatPromptTemplate.from_messages([
            ("system", system_message),
            MessagesPlaceholder(variable_name="chat_history"),
            ("human", "{input}"),
            MessagesPlaceholder(variable_name="agent_scratchpad")
        ])
        
        agent = create_openai_functions_agent(
            llm=self.llm,
            tools=self.tools,
            prompt=prompt
        )
        
        agent_executor = AgentExecutor(
            agent=agent,
            tools=self.tools,
            memory=self.memory,
            verbose=True,
            handle_parsing_errors=True
        )
        
        return agent_executor
    
    def chat(self, user_input: str) -> str:
        """์‚ฌ์šฉ์ž ์ž…๋ ฅ์„ ๋ฐ›์•„ ์‘๋‹ต ์ƒ์„ฑ"""
        try:
            response = self.agent.invoke({"input": user_input})
            return response["output"]
        except Exception as e:
            return f"์ฃ„์†กํ•ฉ๋‹ˆ๋‹ค. ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ–ˆ์Šต๋‹ˆ๋‹ค: {str(e)}"
๐ŸŽฏ ํ•ต์‹ฌ ํฌ์ธํŠธ ์„ค๋ช… 1. Tools ์ •์˜: ๊ฐ ๋ธ”๋ก์ฒด์ธ ์กฐํšŒ ํ•จ์ˆ˜๋ฅผ Tool๋กœ ๋ž˜ํ•‘ํ–ˆ์–ด. LangChain์ด ์ด ๋„๊ตฌ๋“ค์˜ ์„ค๋ช…(description)์„ ๋ณด๊ณ  ์–ธ์ œ ์‚ฌ์šฉํ• ์ง€ ํŒ๋‹จํ•ด.

2. Memory: ConversationBufferMemory๋ฅผ ์‚ฌ์šฉํ•ด์„œ ๋Œ€ํ™” ๋งฅ๋ฝ์„ ๊ธฐ์–ตํ•ด. ์ด์ „ ๋Œ€ํ™” ๋‚ด์šฉ์„ ์ฐธ๊ณ ํ•  ์ˆ˜ ์žˆ์–ด.

3. System Prompt: AI์˜ ์—ญํ• ๊ณผ ํ–‰๋™ ๋ฐฉ์‹์„ ์ •์˜ํ–ˆ์–ด. ์ด๊ฒŒ ์ฑ—๋ด‡์˜ ์„ฑ๊ฒฉ์„ ๊ฒฐ์ •ํ•˜์ง€.

4. Agent Executor: ์‹ค์ œ๋กœ ๋„๊ตฌ๋ฅผ ์‹คํ–‰ํ•˜๊ณ  ๊ฒฐ๊ณผ๋ฅผ ์ฒ˜๋ฆฌํ•˜๋Š” ํ•ต์‹ฌ ์ปดํฌ๋„ŒํŠธ์•ผ.

์ด์ œ ์ฑ—๋ด‡์„ ํ…Œ์ŠคํŠธํ•ด๋ณด์ž! ๐Ÿš€

# test_chatbot.py
from langchain_agent import BlockchainChatbot

# ์ฑ—๋ด‡ ์ดˆ๊ธฐํ™”
chatbot = BlockchainChatbot(network="mainnet")

# ๋Œ€ํ™” ์‹œ์ž‘
print("๐Ÿค– ๋ธ”๋ก์ฒด์ธ ์ฑ—๋ด‡์ด ์ค€๋น„๋˜์—ˆ์Šต๋‹ˆ๋‹ค!")
print("=" * 50)

# ์˜ˆ์‹œ ์งˆ๋ฌธ๋“ค
questions = [
    "์ตœ์‹  ๋ธ”๋ก ์ •๋ณด๋ฅผ ์•Œ๋ ค์ค˜",
    "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 ์ฃผ์†Œ์˜ ์ž”์•ก์ด ์–ผ๋งˆ์•ผ?",
    "๋ฐฉ๊ธˆ ์กฐํšŒํ•œ ์ฃผ์†Œ๊ฐ€ ๋ˆ„๊ตฌ ๊ฑฐ์•ผ?"
]

for question in questions:
    print(f"\n๐Ÿ‘ค ์‚ฌ์šฉ์ž: {question}")
    response = chatbot.chat(question)
    print(f"๐Ÿค– ์ฑ—๋ด‡: {response}")
    print("-" * 50)

์‹คํ–‰ํ•˜๋ฉด ์ฑ—๋ด‡์ด ์งˆ๋ฌธ์„ ์ดํ•ดํ•˜๊ณ , ์ ์ ˆํ•œ ๋„๊ตฌ๋ฅผ ์„ ํƒํ•ด์„œ, ๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ๋ฅผ ์กฐํšŒํ•œ ๋‹ค์Œ, ์นœ์ ˆํ•˜๊ฒŒ ์„ค๋ช…ํ•ด์ฃผ๋Š” ๊ฑธ ๋ณผ ์ˆ˜ ์žˆ์–ด! โœจ


๐ŸŽจ ์‚ฌ์šฉ์ž ์ธํ„ฐํŽ˜์ด์Šค ๋งŒ๋“ค๊ธฐ

์ด์ œ ์‹ค์ œ๋กœ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๋งŒ๋“ค์–ด๋ณด์ž. ๊ฐ„๋‹จํ•œ CLI(Command Line Interface)๋ถ€ํ„ฐ ์‹œ์ž‘ํ• ๊ฒŒ. ๐Ÿ’ฌ

main.py ํŒŒ์ผ์„ ๋งŒ๋“ค์–ด๋ณด์ž:

from langchain_agent import BlockchainChatbot
import sys

def print_welcome():
    """ํ™˜์˜ ๋ฉ”์‹œ์ง€ ์ถœ๋ ฅ"""
    print("\n" + "="*60)
    print("๐Ÿค– ๋ธ”๋ก์ฒด์ธ AI ์ฑ—๋ด‡์— ์˜ค์‹  ๊ฒƒ์„ ํ™˜์˜ํ•ฉ๋‹ˆ๋‹ค!")
    print("="*60)
    print("\n์ด ์ฑ—๋ด‡์€ ๋‹ค์Œ๊ณผ ๊ฐ™์€ ์งˆ๋ฌธ์— ๋‹ตํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค:")
    print("  โ€ข ์ง€๊ฐ‘ ์ฃผ์†Œ์˜ ์ž”์•ก ์กฐํšŒ")
    print("  โ€ข ํŠธ๋žœ์žญ์…˜ ์ •๋ณด ํ™•์ธ")
    print("  โ€ข ์ตœ์‹  ๋ธ”๋ก ์ •๋ณด ์กฐํšŒ")
    print("  โ€ข ๋ธ”๋ก์ฒด์ธ ์šฉ์–ด ์„ค๋ช…")
    print("\n๋ช…๋ น์–ด:")
    print("  'quit' ๋˜๋Š” 'exit' - ์ข…๋ฃŒ")
    print("  'clear' - ๋Œ€ํ™” ๊ธฐ๋ก ์ดˆ๊ธฐํ™”")
    print("="*60 + "\n")

def main():
    """๋ฉ”์ธ ์‹คํ–‰ ํ•จ์ˆ˜"""
    print_welcome()
    
    # ๋„คํŠธ์›Œํฌ ์„ ํƒ
    print("์—ฐ๊ฒฐํ•  ๋„คํŠธ์›Œํฌ๋ฅผ ์„ ํƒํ•˜์„ธ์š”:")
    print("1. Mainnet (๊ธฐ๋ณธ)")
    print("2. Goerli Testnet")
    print("3. Sepolia Testnet")
    
    choice = input("\n์„ ํƒ (1-3, ์—”ํ„ฐ=๊ธฐ๋ณธ): ").strip()
    
    network_map = {
        "1": "mainnet",
        "2": "goerli",
        "3": "sepolia",
        "": "mainnet"
    }
    
    network = network_map.get(choice, "mainnet")
    
    try:
        # ์ฑ—๋ด‡ ์ดˆ๊ธฐํ™”
        print(f"\n๐Ÿ”„ {network} ๋„คํŠธ์›Œํฌ์— ์—ฐ๊ฒฐ ์ค‘...")
        chatbot = BlockchainChatbot(network=network)
        print("โœ… ์—ฐ๊ฒฐ ์™„๋ฃŒ!\n")
        
        # ๋Œ€ํ™” ๋ฃจํ”„
        while True:
            try:
                user_input = input("๐Ÿ‘ค You: ").strip()
                
                if not user_input:
                    continue
                
                # ์ข…๋ฃŒ ๋ช…๋ น
                if user_input.lower() in ['quit', 'exit', '์ข…๋ฃŒ']:
                    print("\n๐Ÿ‘‹ ์ฑ—๋ด‡์„ ์ข…๋ฃŒํ•ฉ๋‹ˆ๋‹ค. ์•ˆ๋…•ํžˆ ๊ฐ€์„ธ์š”!")
                    break
                
                # ๋Œ€ํ™” ๊ธฐ๋ก ์ดˆ๊ธฐํ™”
                if user_input.lower() in ['clear', '์ดˆ๊ธฐํ™”']:
                    chatbot.memory.clear()
                    print("๐Ÿ”„ ๋Œ€ํ™” ๊ธฐ๋ก์ด ์ดˆ๊ธฐํ™”๋˜์—ˆ์Šต๋‹ˆ๋‹ค.\n")
                    continue
                
                # ์ฑ—๋ด‡ ์‘๋‹ต
                print("\n๐Ÿค– Chatbot: ", end="")
                response = chatbot.chat(user_input)
                print(response)
                print("\n" + "-"*60 + "\n")
                
            except KeyboardInterrupt:
                print("\n\n๐Ÿ‘‹ ์ฑ—๋ด‡์„ ์ข…๋ฃŒํ•ฉ๋‹ˆ๋‹ค.")
                break
            except Exception as e:
                print(f"\nโŒ ์˜ค๋ฅ˜ ๋ฐœ์ƒ: {str(e)}\n")
                continue
    
    except Exception as e:
        print(f"\nโŒ ์ดˆ๊ธฐํ™” ์‹คํŒจ: {str(e)}")
        print("API ํ‚ค์™€ ๋„คํŠธ์›Œํฌ ์„ค์ •์„ ํ™•์ธํ•ด์ฃผ์„ธ์š”.")
        sys.exit(1)

if __name__ == "__main__":
    main()

์ด์ œ ์‹คํ–‰ํ•ด๋ณด์ž:

python main.py
๐Ÿ’ก ์‚ฌ์šฉ ํŒ: โ€ข ์ง€๊ฐ‘ ์ฃผ์†Œ๋‚˜ ํŠธ๋žœ์žญ์…˜ ํ•ด์‹œ๋ฅผ ๋ณต์‚ฌ-๋ถ™์—ฌ๋„ฃ๊ธฐ ํ•  ๋•Œ ์ •ํ™•ํžˆ ์ž…๋ ฅํ•ด์•ผ ํ•ด
โ€ข ์ž์—ฐ์–ด๋กœ ํŽธํ•˜๊ฒŒ ์งˆ๋ฌธํ•ด๋„ AI๊ฐ€ ์ดํ•ดํ•ด
โ€ข ์ด์ „ ๋Œ€ํ™” ๋งฅ๋ฝ์„ ๊ธฐ์–ตํ•˜๋‹ˆ๊นŒ ์—ฐ์†๋œ ์งˆ๋ฌธ๋„ ๊ฐ€๋Šฅํ•ด
โ€ข ๋ชจ๋ฅด๋Š” ๋ธ”๋ก์ฒด์ธ ์šฉ์–ด๊ฐ€ ์žˆ์œผ๋ฉด ๊ทธ๋ƒฅ ๋ฌผ์–ด๋ด!

์‹ค์ œ ์‚ฌ์šฉ ์˜ˆ์‹œ๋ฅผ ๋ณด์ž๋ฉด: ๐Ÿ’ญ

๋Œ€ํ™” ์˜ˆ์‹œ ๐Ÿ‘ค You: ์ตœ์‹  ๋ธ”๋ก ์ •๋ณด ์•Œ๋ ค์ค˜
๐Ÿค– Chatbot: ํ˜„์žฌ ์ด๋”๋ฆฌ์›€ ๋ฉ”์ธ๋„ท์˜ ์ตœ์‹  ๋ธ”๋ก์€ #18,500,123์ž…๋‹ˆ๋‹ค. ์ด ๋ธ”๋ก์—๋Š” 150๊ฐœ์˜ ํŠธ๋žœ์žญ์…˜์ด ํฌํ•จ๋˜์–ด ์žˆ์œผ๋ฉฐ...

๐Ÿ‘ค You: ๊ทธ ๋ธ”๋ก์˜ ๊ฐ€์Šค๋น„๋Š” ์–ด๋–ป๊ฒŒ ๋ผ?
๐Ÿค– Chatbot: ํ•ด๋‹น ๋ธ”๋ก์—์„œ ์‚ฌ์šฉ๋œ ์ด ๊ฐ€์Šค๋Š” 15,000,000 ๊ฐ€์Šค์ž…๋‹ˆ๋‹ค. ๋ธ”๋ก ๊ฐ€์Šค ํ•œ๋„๋Š” 30,000,000์ด๋ฏ€๋กœ ์•ฝ 50%๊ฐ€ ์‚ฌ์šฉ๋˜์—ˆ๋„ค์š”...

๐Ÿ” ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ ์ถ”๊ฐ€ํ•˜๊ธฐ

๊ธฐ๋ณธ ๊ธฐ๋Šฅ์€ ์™„์„ฑํ–ˆ์–ด! ์ด์ œ ์ข€ ๋” ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ๋“ค์„ ์ถ”๊ฐ€ํ•ด๋ณด์ž. โšก

1. ์Šค๋งˆํŠธ ์ปจํŠธ๋ž™ํŠธ ์ƒํ˜ธ์ž‘์šฉ

์Šค๋งˆํŠธ ์ปจํŠธ๋ž™ํŠธ์˜ ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•˜๊ณ  ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ์„ ์ˆ˜ ์žˆ๋Š” ๊ธฐ๋Šฅ์„ ์ถ”๊ฐ€ํ•ด๋ณด์ž.

# blockchain_connector.py์— ์ถ”๊ฐ€
def get_contract_info(self, contract_address: str, abi: list) -> Dict:
    """์Šค๋งˆํŠธ ์ปจํŠธ๋ž™ํŠธ ์ •๋ณด ์กฐํšŒ"""
    try:
        checksum_address = Web3.to_checksum_address(contract_address)
        contract = self.w3.eth.contract(address=checksum_address, abi=abi)
        
        # ๊ธฐ๋ณธ ์ •๋ณด ์กฐํšŒ
        info = {
            "address": contract_address,
            "code_size": len(self.w3.eth.get_code(checksum_address))
        }
        
        # ์ผ๋ฐ˜์ ์ธ ERC-20 ํ•จ์ˆ˜๋“ค ์‹œ๋„
        try:
            info["name"] = contract.functions.name().call()
            info["symbol"] = contract.functions.symbol().call()
            info["decimals"] = contract.functions.decimals().call()
            info["total_supply"] = contract.functions.totalSupply().call()
        except:
            pass
        
        return info
    except Exception as e:
        return {"error": str(e)}

def get_token_balance(self, contract_address: str, wallet_address: str, abi: list) -> Dict:
    """ERC-20 ํ† ํฐ ์ž”์•ก ์กฐํšŒ"""
    try:
        checksum_contract = Web3.to_checksum_address(contract_address)
        checksum_wallet = Web3.to_checksum_address(wallet_address)
        
        contract = self.w3.eth.contract(address=checksum_contract, abi=abi)
        
        balance = contract.functions.balanceOf(checksum_wallet).call()
        decimals = contract.functions.decimals().call()
        symbol = contract.functions.symbol().call()
        
        # ์‹ค์ œ ํ† ํฐ ์ˆ˜๋Ÿ‰์œผ๋กœ ๋ณ€ํ™˜
        token_balance = balance / (10 ** decimals)
        
        return {
            "wallet": wallet_address,
            "token_address": contract_address,
            "balance": token_balance,
            "symbol": symbol,
            "decimals": decimals
        }
    except Exception as e:
        return {"error": str(e)}
2. ๋ฒกํ„ฐ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค๋กœ ์ง€์‹ ์ €์žฅ

ChromaDB๋ฅผ ์‚ฌ์šฉํ•ด์„œ ๋ธ”๋ก์ฒด์ธ ๊ด€๋ จ ์ง€์‹์„ ์ €์žฅํ•˜๊ณ  ๊ฒ€์ƒ‰ํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋งŒ๋“ค์–ด๋ณด์ž. ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ์ฑ—๋ด‡์ด ๋” ๋งŽ์€ ์ •๋ณด๋ฅผ ๊ธฐ์–ตํ•˜๊ณ  ํ™œ์šฉํ•  ์ˆ˜ ์žˆ์–ด. ๐Ÿง 

# knowledge_base.py
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import TextLoader
import os

class BlockchainKnowledgeBase:
    """๋ธ”๋ก์ฒด์ธ ์ง€์‹ ๋ฒ ์ด์Šค"""
    
    def __init__(self, persist_directory: str = "./chroma_db"):
        self.embeddings = OpenAIEmbeddings(
            openai_api_key=os.getenv("OPENAI_API_KEY")
        )
        
        self.vectorstore = Chroma(
            persist_directory=persist_directory,
            embedding_function=self.embeddings
        )
    
    def add_knowledge(self, text: str, metadata: dict = None):
        """์ง€์‹ ์ถ”๊ฐ€"""
        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200
        )
        
        chunks = text_splitter.split_text(text)
        
        self.vectorstore.add_texts(
            texts=chunks,
            metadatas=[metadata] * len(chunks) if metadata else None
        )
        
        self.vectorstore.persist()
    
    def search(self, query: str, k: int = 3):
        """๊ด€๋ จ ์ง€์‹ ๊ฒ€์ƒ‰"""
        results = self.vectorstore.similarity_search(query, k=k)
        return results
    
    def add_blockchain_basics(self):
        """๊ธฐ๋ณธ ๋ธ”๋ก์ฒด์ธ ์ง€์‹ ์ถ”๊ฐ€"""
        basics = """
        ๋ธ”๋ก์ฒด์ธ์€ ๋ถ„์‚ฐ ์›์žฅ ๊ธฐ์ˆ ์ž…๋‹ˆ๋‹ค. 
        
        ์ฃผ์š” ๊ฐœ๋…:
        - ๋ธ”๋ก: ํŠธ๋žœ์žญ์…˜๋“ค์˜ ๋ฌถ์Œ
        - ํ•ด์‹œ: ๋ธ”๋ก์˜ ๊ณ ์œ  ์‹๋ณ„์ž
        - ๊ฐ€์Šค(Gas): ์ด๋”๋ฆฌ์›€์—์„œ ํŠธ๋žœ์žญ์…˜ ์‹คํ–‰ ๋น„์šฉ
        - ์Šค๋งˆํŠธ ์ปจํŠธ๋ž™ํŠธ: ๋ธ”๋ก์ฒด์ธ์—์„œ ์‹คํ–‰๋˜๋Š” ํ”„๋กœ๊ทธ๋žจ
        - ์ง€๊ฐ‘ ์ฃผ์†Œ: 0x๋กœ ์‹œ์ž‘ํ•˜๋Š” 42์ž๋ฆฌ 16์ง„์ˆ˜
        - ํŠธ๋žœ์žญ์…˜ ํ•ด์‹œ: ๊ฑฐ๋ž˜์˜ ๊ณ ์œ  ์‹๋ณ„์ž
        
        ์ด๋”๋ฆฌ์›€ ๋„คํŠธ์›Œํฌ:
        - Mainnet: ์‹ค์ œ ETH๊ฐ€ ๊ฑฐ๋ž˜๋˜๋Š” ๋ฉ”์ธ ๋„คํŠธ์›Œํฌ
        - Testnet: ๊ฐœ๋ฐœ/ํ…Œ์ŠคํŠธ์šฉ ๋„คํŠธ์›Œํฌ (Goerli, Sepolia ๋“ฑ)
        
        ERC-20: ์ด๋”๋ฆฌ์›€์˜ ํ† ํฐ ํ‘œ์ค€
        ERC-721: NFT ํ‘œ์ค€
        """
        
        self.add_knowledge(basics, {"type": "basics"})
        print("โœ… ๊ธฐ๋ณธ ์ง€์‹์ด ์ถ”๊ฐ€๋˜์—ˆ์Šต๋‹ˆ๋‹ค.")

์ด์ œ ์ฑ—๋ด‡์— ์ง€์‹ ๋ฒ ์ด์Šค๋ฅผ ํ†ตํ•ฉํ•ด๋ณด์ž:

# langchain_agent.py์— ์ถ”๊ฐ€
from knowledge_base import BlockchainKnowledgeBase

class BlockchainChatbot:
    def __init__(self, network: str = "mainnet", use_knowledge_base: bool = True):
        # ... ๊ธฐ์กด ์ฝ”๋“œ ...
        
        # ์ง€์‹ ๋ฒ ์ด์Šค ์ดˆ๊ธฐํ™”
        if use_knowledge_base:
            self.kb = BlockchainKnowledgeBase()
            # ๊ธฐ๋ณธ ์ง€์‹ ์ถ”๊ฐ€ (์ฒ˜์Œ ํ•œ ๋ฒˆ๋งŒ)
            # self.kb.add_blockchain_basics()
    
    def _create_tools(self) -> list:
        tools = [
            # ... ๊ธฐ์กด ๋„๊ตฌ๋“ค ...
        ]
        
        # ์ง€์‹ ๊ฒ€์ƒ‰ ๋„๊ตฌ ์ถ”๊ฐ€
        if hasattr(self, 'kb'):
            def search_knowledge_tool(query: str) -> str:
                """๋ธ”๋ก์ฒด์ธ ๊ด€๋ จ ์ง€์‹์„ ๊ฒ€์ƒ‰ํ•ฉ๋‹ˆ๋‹ค."""
                results = self.kb.search(query, k=2)
                if not results:
                    return "๊ด€๋ จ ์ •๋ณด๋ฅผ ์ฐพ์ง€ ๋ชปํ–ˆ์Šต๋‹ˆ๋‹ค."
                
                knowledge = "\n\n".join([doc.page_content for doc in results])
                return f"๊ด€๋ จ ์ง€์‹:\n{knowledge}"
            
            tools.append(
                Tool(
                    name="search_blockchain_knowledge",
                    func=search_knowledge_tool,
                    description="๋ธ”๋ก์ฒด์ธ ์šฉ์–ด๋‚˜ ๊ฐœ๋…์„ ์„ค๋ช…ํ•  ๋•Œ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ์ž…๋ ฅ: ๊ฒ€์ƒ‰ํ•  ์šฉ์–ด๋‚˜ ์งˆ๋ฌธ"
                )
            )
        
        return tools
๐Ÿ’ก ๋ฒกํ„ฐ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค์˜ ์žฅ์ : โ€ข ์˜๋ฏธ์  ์œ ์‚ฌ์„ฑ ๊ฒ€์ƒ‰: ์ •ํ™•ํžˆ ๊ฐ™์€ ๋‹จ์–ด๊ฐ€ ์•„๋‹ˆ์–ด๋„ ๋น„์Šทํ•œ ์˜๋ฏธ์˜ ์ •๋ณด๋ฅผ ์ฐพ์•„์ค˜
โ€ข ํ™•์žฅ ๊ฐ€๋Šฅ: ์ƒˆ๋กœ์šด ์ง€์‹์„ ๊ณ„์† ์ถ”๊ฐ€ํ•  ์ˆ˜ ์žˆ์–ด
โ€ข ๋น ๋ฅธ ๊ฒ€์ƒ‰: ์ˆ˜์ฒœ ๊ฐœ์˜ ๋ฌธ์„œ์—์„œ๋„ ๋น ๋ฅด๊ฒŒ ๊ด€๋ จ ์ •๋ณด๋ฅผ ์ฐพ์•„
โ€ข ๋งฅ๋ฝ ์ดํ•ด: ๋‹จ์ˆœ ํ‚ค์›Œ๋“œ ๋งค์นญ์ด ์•„๋‹Œ ๋ฌธ๋งฅ์„ ์ดํ•ดํ•ด์„œ ๊ฒ€์ƒ‰ํ•ด
3. ํŠธ๋žœ์žญ์…˜ ๋ถ„์„ ๊ธฐ๋Šฅ

์—ฌ๋Ÿฌ ํŠธ๋žœ์žญ์…˜์„ ๋ถ„์„ํ•ด์„œ ํŒจํ„ด์„ ์ฐพ์•„๋‚ด๋Š” ๊ธฐ๋Šฅ์„ ์ถ”๊ฐ€ํ•ด๋ณด์ž. ๐Ÿ“Š

# blockchain_connector.py์— ์ถ”๊ฐ€
def analyze_address_activity(self, address: str, limit: int = 10) -> Dict:
    """์ง€๊ฐ‘ ์ฃผ์†Œ์˜ ์ตœ๊ทผ ํ™œ๋™ ๋ถ„์„"""
    try:
        checksum_address = Web3.to_checksum_address(address)
        
        # Etherscan API๋ฅผ ์‚ฌ์šฉํ•ด์„œ ํŠธ๋žœ์žญ์…˜ ๋ชฉ๋ก ๊ฐ€์ ธ์˜ค๊ธฐ
        # (์‹ค์ œ๋กœ๋Š” Etherscan API ํ‚ค๊ฐ€ ํ•„์š”)
        import requests
        
        etherscan_key = os.getenv("ETHERSCAN_API_KEY")
        url = f"https://api.etherscan.io/api"
        params = {
            "module": "account",
            "action": "txlist",
            "address": address,
            "startblock": 0,
            "endblock": 99999999,
            "page": 1,
            "offset": limit,
            "sort": "desc",
            "apikey": etherscan_key
        }
        
        response = requests.get(url, params=params)
        data = response.json()
        
        if data["status"] != "1":
            return {"error": "ํŠธ๋žœ์žญ์…˜ ์กฐํšŒ ์‹คํŒจ"}
        
        transactions = data["result"]
        
        # ๋ถ„์„
        total_sent = 0
        total_received = 0
        unique_addresses = set()
        
        for tx in transactions:
            value_eth = float(self.w3.from_wei(int(tx["value"]), 'ether'))
            
            if tx["from"].lower() == address.lower():
                total_sent += value_eth
            else:
                total_received += value_eth
            
            unique_addresses.add(tx["from"])
            unique_addresses.add(tx["to"])
        
        return {
            "address": address,
            "transaction_count": len(transactions),
            "total_sent_eth": round(total_sent, 4),
            "total_received_eth": round(total_received, 4),
            "net_flow_eth": round(total_received - total_sent, 4),
            "unique_interactions": len(unique_addresses) - 1,
            "recent_transactions": transactions[:5]
        }
    except Exception as e:
        return {"error": str(e)}

๐ŸŽฏ ์‹ค์ „ ํ™œ์šฉ ์‹œ๋‚˜๋ฆฌ์˜ค

์ด์ œ ์šฐ๋ฆฌ๊ฐ€ ๋งŒ๋“  ์ฑ—๋ด‡์„ ์‹ค์ œ๋กœ ์–ด๋–ป๊ฒŒ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ๋Š”์ง€ ์‚ดํŽด๋ณด์ž. ๐ŸŒŸ

๐Ÿ’ผ ํˆฌ์ž ๋ถ„์„ "์ด ์ง€๊ฐ‘์ด ์ตœ๊ทผ์— ์–ด๋–ค ํ† ํฐ์„ ๋งŽ์ด ์ƒ€๋Š”์ง€ ๋ถ„์„ํ•ด์ค˜"

โ†’ ๋Œ€ํ˜• ํˆฌ์ž์ž(๊ณ ๋ž˜)์˜ ์›€์ง์ž„์„ ์ถ”์ ํ•˜๊ณ  ํˆฌ์ž ์ธ์‚ฌ์ดํŠธ๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ์–ด.
๐Ÿ” ์‚ฌ๊ธฐ ํƒ์ง€ "์ด ์ปจํŠธ๋ž™ํŠธ ์ฃผ์†Œ๊ฐ€ ์•ˆ์ „ํ•œ์ง€ ํ™•์ธํ•ด์ค˜"

โ†’ ์Šค๋งˆํŠธ ์ปจํŠธ๋ž™ํŠธ์˜ ์ฝ”๋“œ์™€ ๊ฑฐ๋ž˜ ํŒจํ„ด์„ ๋ถ„์„ํ•ด์„œ ์˜์‹ฌ์Šค๋Ÿฌ์šด ํ™œ๋™์„ ์ฐพ์•„๋‚ผ ์ˆ˜ ์žˆ์–ด.
๐Ÿ“Š ํฌํŠธํด๋ฆฌ์˜ค ๊ด€๋ฆฌ "๋‚ด ์ง€๊ฐ‘์˜ ๋ชจ๋“  ํ† ํฐ ์ž”์•ก์„ ์ •๋ฆฌํ•ด์ค˜"

โ†’ ์—ฌ๋Ÿฌ ํ† ํฐ์˜ ์ž”์•ก์„ ํ•œ ๋ฒˆ์— ์กฐํšŒํ•˜๊ณ  ์ด ๊ฐ€์น˜๋ฅผ ๊ณ„์‚ฐํ•  ์ˆ˜ ์žˆ์–ด.
๐ŸŽ“ ๊ต์œก "๊ฐ€์Šค๋น„๊ฐ€ ๋ญ์•ผ? ์™œ ํ•„์š”ํ•œ ๊ฑฐ์•ผ?"

โ†’ ๋ธ”๋ก์ฒด์ธ ์ดˆ๋ณด์ž๋“ค์—๊ฒŒ ๊ฐœ๋…์„ ์‰ฝ๊ฒŒ ์„ค๋ช…ํ•ด์ค„ ์ˆ˜ ์žˆ์–ด.
๐ŸŽฌ ์‹ค์ œ ์‚ฌ์šฉ ์˜ˆ์‹œ: NFT ๊ฑฐ๋ž˜ ๋ถ„์„ ์‚ฌ์šฉ์ž: "0x1234...abcd ์ฃผ์†Œ๊ฐ€ ์ตœ๊ทผ์— ๊ตฌ๋งคํ•œ NFT๋“ค์„ ๋ถ„์„ํ•ด์ค˜"

์ฑ—๋ด‡ ์ฒ˜๋ฆฌ ๊ณผ์ •:
1. ์ฃผ์†Œ์˜ ์ตœ๊ทผ ํŠธ๋žœ์žญ์…˜ ์กฐํšŒ
2. ERC-721 ํ† ํฐ ์ „์†ก ์ด๋ฒคํŠธ ํ•„ํ„ฐ๋ง
3. ๊ฐ NFT ์ปจํŠธ๋ž™ํŠธ ์ •๋ณด ์กฐํšŒ
4. ๊ตฌ๋งค ๊ฐ€๊ฒฉ๊ณผ ์‹œ๊ธฐ ๋ถ„์„
5. ๊ฒฐ๊ณผ๋ฅผ ์ดํ•ดํ•˜๊ธฐ ์‰ฝ๊ฒŒ ์š”์•ฝ

์ฑ—๋ด‡ ์‘๋‹ต: "ํ•ด๋‹น ์ฃผ์†Œ๋Š” ์ตœ๊ทผ 7์ผ๊ฐ„ 3๊ฐœ์˜ NFT๋ฅผ ๊ตฌ๋งคํ–ˆ์Šต๋‹ˆ๋‹ค. Bored Ape #1234๋ฅผ 50 ETH์—, CryptoPunk #5678์„ 80 ETH์— ๊ตฌ๋งคํ–ˆ์œผ๋ฉฐ, ์ด ํˆฌ์ž์•ก์€ ์•ฝ 150 ETH์ž…๋‹ˆ๋‹ค..."

์ด๋Ÿฐ ์‹์œผ๋กœ ๋ณต์žกํ•œ ๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ๋ฅผ ๋ˆ„๊ตฌ๋‚˜ ์‰ฝ๊ฒŒ ์ดํ•ดํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋งŒ๋“ค์–ด์ฃผ๋Š” ๊ฑฐ์•ผ! ๐ŸŽ‰


โšก ์„ฑ๋Šฅ ์ตœ์ ํ™” ํŒ

์ฑ—๋ด‡์ด ์ž˜ ์ž‘๋™ํ•˜๋Š” ๊ฑด ์ข‹์€๋ฐ, ๋” ๋น ๋ฅด๊ณ  ํšจ์œจ์ ์œผ๋กœ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด. ๋ช‡ ๊ฐ€์ง€ ์ตœ์ ํ™” ๋ฐฉ๋ฒ•์„ ์•Œ๋ ค์ค„๊ฒŒ. ๐Ÿš€

1. ์บ์‹ฑ ์ „๋žต

๊ฐ™์€ ๋ฐ์ดํ„ฐ๋ฅผ ๋ฐ˜๋ณตํ•ด์„œ ์กฐํšŒํ•˜๋Š” ๊ฑด ๋น„ํšจ์œจ์ ์ด์•ผ. ์บ์‹ฑ์„ ๊ตฌํ˜„ํ•ด๋ณด์ž:

# cache_manager.py
from functools import lru_cache
from datetime import datetime, timedelta
import json

class CacheManager:
    """๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ ์บ์‹ฑ ๊ด€๋ฆฌ์ž"""
    
    def __init__(self, ttl_seconds: int = 300):
        self.cache = {}
        self.ttl = ttl_seconds
    
    def get(self, key: str):
        """์บ์‹œ์—์„œ ๋ฐ์ดํ„ฐ ๊ฐ€์ ธ์˜ค๊ธฐ"""
        if key in self.cache:
            data, timestamp = self.cache[key]
            
            # TTL ํ™•์ธ
            if datetime.now() - timestamp < timedelta(seconds=self.ttl):
                return data
            else:
                # ๋งŒ๋ฃŒ๋œ ์บ์‹œ ์‚ญ์ œ
                del self.cache[key]
        
        return None
    
    def set(self, key: str, value):
        """์บ์‹œ์— ๋ฐ์ดํ„ฐ ์ €์žฅ"""
        self.cache[key] = (value, datetime.now())
    
    def clear(self):
        """์บ์‹œ ์ „์ฒด ์‚ญ์ œ"""
        self.cache.clear()

# blockchain_connector.py์— ์ ์šฉ
class BlockchainConnector:
    def __init__(self, network: str = "mainnet"):
        # ... ๊ธฐ์กด ์ฝ”๋“œ ...
        self.cache = CacheManager(ttl_seconds=60)  # 1๋ถ„ ์บ์‹œ
    
    def get_balance(self, address: str) -> Dict:
        # ์บ์‹œ ํ™•์ธ
        cache_key = f"balance_{address}"
        cached = self.cache.get(cache_key)
        if cached:
            return cached
        
        # ์‹ค์ œ ์กฐํšŒ
        result = self._fetch_balance(address)
        
        # ์บ์‹œ ์ €์žฅ
        self.cache.set(cache_key, result)
        return result
2. ๋น„๋™๊ธฐ ์ฒ˜๋ฆฌ

์—ฌ๋Ÿฌ API ํ˜ธ์ถœ์„ ๋™์‹œ์— ์ฒ˜๋ฆฌํ•˜๋ฉด ํ›จ์”ฌ ๋นจ๋ผ์ ธ:

import asyncio
import aiohttp

async def fetch_multiple_balances(addresses: list) -> list:
    """์—ฌ๋Ÿฌ ์ฃผ์†Œ์˜ ์ž”์•ก์„ ๋™์‹œ์— ์กฐํšŒ"""
    async with aiohttp.ClientSession() as session:
        tasks = []
        for address in addresses:
            task = fetch_balance_async(session, address)
            tasks.append(task)
        
        results = await asyncio.gather(*tasks)
        return results

async def fetch_balance_async(session, address: str):
    """๋น„๋™๊ธฐ ์ž”์•ก ์กฐํšŒ"""
    # API ํ˜ธ์ถœ ๋กœ์ง
    pass
3. ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ

๋งŽ์€ ๋ฐ์ดํ„ฐ๋ฅผ ์ฒ˜๋ฆฌํ•  ๋•Œ๋Š” ๋ฐฐ์น˜๋กœ ๋‚˜๋ˆ ์„œ ์ฒ˜๋ฆฌํ•˜๋Š” ๊ฒŒ ์ข‹์•„:

def process_transactions_batch(tx_hashes: list, batch_size: int = 10):
    """ํŠธ๋žœ์žญ์…˜์„ ๋ฐฐ์น˜๋กœ ์ฒ˜๋ฆฌ"""
    results = []
    
    for i in range(0, len(tx_hashes), batch_size):
        batch = tx_hashes[i:i + batch_size]
        batch_results = [get_transaction(tx) for tx in batch]
        results.extend(batch_results)
        
        # API ๋ ˆ์ดํŠธ ๋ฆฌ๋ฐ‹ ๋ฐฉ์ง€
        time.sleep(0.5)
    
    return results
โš ๏ธ API ๋ ˆ์ดํŠธ ๋ฆฌ๋ฐ‹ ์ฃผ์˜! ๋Œ€๋ถ€๋ถ„์˜ ๋ธ”๋ก์ฒด์ธ API๋Š” ์š”์ฒญ ํšŸ์ˆ˜ ์ œํ•œ์ด ์žˆ์–ด. Infura๋Š” ๋ฌด๋ฃŒ ํ”Œ๋žœ์—์„œ ํ•˜๋ฃจ 100,000 ์š”์ฒญ, Etherscan์€ ์ดˆ๋‹น 5 ์š”์ฒญ๊นŒ์ง€ ๊ฐ€๋Šฅํ•ด. ์ด ํ•œ๋„๋ฅผ ๋„˜์œผ๋ฉด ์ผ์‹œ์ ์œผ๋กœ ์ฐจ๋‹จ๋  ์ˆ˜ ์žˆ์œผ๋‹ˆ ์ฃผ์˜ํ•ด์•ผ ํ•ด!

๐Ÿ”’ ๋ณด์•ˆ ๊ณ ๋ ค์‚ฌํ•ญ

๋ธ”๋ก์ฒด์ธ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์„ ๋งŒ๋“ค ๋•Œ๋Š” ๋ณด์•ˆ์ด ์ •๋ง ์ค‘์š”ํ•ด. ๋ช‡ ๊ฐ€์ง€ ํ•„์ˆ˜ ๋ณด์•ˆ ์‚ฌํ•ญ๋“ค์„ ์ฒดํฌํ•ด๋ณด์ž. ๐Ÿ›ก๏ธ

๐Ÿ” API ํ‚ค ๋ณด์•ˆ ์ ˆ๋Œ€ ํ•˜์ง€ ๋ง์•„์•ผ ํ•  ๊ฒƒ:
โŒ ์ฝ”๋“œ์— API ํ‚ค ํ•˜๋“œ์ฝ”๋”ฉ
โŒ ๊นƒํ—ˆ๋ธŒ์— .env ํŒŒ์ผ ์—…๋กœ๋“œ
โŒ ํด๋ผ์ด์–ธํŠธ ์‚ฌ์ด๋“œ์— API ํ‚ค ๋…ธ์ถœ

ํ•ด์•ผ ํ•  ๊ฒƒ:
โœ… ํ™˜๊ฒฝ ๋ณ€์ˆ˜ ์‚ฌ์šฉ
โœ… .gitignore์— .env ์ถ”๊ฐ€
โœ… ์„œ๋ฒ„ ์‚ฌ์ด๋“œ์—์„œ๋งŒ API ํ˜ธ์ถœ
โœ… API ํ‚ค ์ •๊ธฐ์ ์œผ๋กœ ๊ต์ฒด
๐Ÿ” ์ž…๋ ฅ ๊ฒ€์ฆ ์‚ฌ์šฉ์ž ์ž…๋ ฅ์€ ํ•ญ์ƒ ๊ฒ€์ฆํ•ด์•ผ ํ•ด:
import re

def validate_ethereum_address(address: str) -> bool:
    """์ด๋”๋ฆฌ์›€ ์ฃผ์†Œ ์œ ํšจ์„ฑ ๊ฒ€์ฆ"""
    # ๊ธฐ๋ณธ ํ˜•์‹ ํ™•์ธ
    if not re.match(r'^0x[a-fA-F0-9]{40}$', address):
        return False
    
    # ์ฒดํฌ์„ฌ ๊ฒ€์ฆ (์„ ํƒ์‚ฌํ•ญ)
    try:
        Web3.to_checksum_address(address)
        return True
    except:
        return False

def validate_transaction_hash(tx_hash: str) -> bool:
    """ํŠธ๋žœ์žญ์…˜ ํ•ด์‹œ ์œ ํšจ์„ฑ ๊ฒ€์ฆ"""
    return bool(re.match(r'^0x[a-fA-F0-9]{64}$', tx_hash))

def sanitize_user_input(user_input: str) -> str:
    """์‚ฌ์šฉ์ž ์ž…๋ ฅ ์ •์ œ"""
    # SQL ์ธ์ ์…˜ ๋ฐฉ์ง€
    dangerous_chars = ["'", '"', ";", "--", "/*", "*/"]
    for char in dangerous_chars:
        user_input = user_input.replace(char, "")
    
    return user_input.strip()
โš–๏ธ ๋ ˆ์ดํŠธ ๋ฆฌ๋ฏธํŒ… ๊ณผ๋„ํ•œ ์š”์ฒญ์„ ๋ฐฉ์ง€ํ•˜๊ธฐ ์œ„ํ•œ ๋ ˆ์ดํŠธ ๋ฆฌ๋ฏธํ„ฐ:
from collections import deque
from time import time

class RateLimiter:
    """๊ฐ„๋‹จํ•œ ๋ ˆ์ดํŠธ ๋ฆฌ๋ฏธํ„ฐ"""
    
    def __init__(self, max_requests: int, time_window: int):
        self.max_requests = max_requests
        self.time_window = time_window
        self.requests = deque()
    
    def allow_request(self) -> bool:
        """์š”์ฒญ ํ—ˆ์šฉ ์—ฌ๋ถ€ ํ™•์ธ"""
        now = time()
        
        # ์‹œ๊ฐ„ ์œˆ๋„์šฐ ๋ฐ–์˜ ์š”์ฒญ ์ œ๊ฑฐ
        while self.requests and self.requests[0] < now - self.time_window:
            self.requests.popleft()
        
        # ์š”์ฒญ ์ˆ˜ ํ™•์ธ
        if len(self.requests) < self.max_requests:
            self.requests.append(now)
            return True
        
        return False

# ์‚ฌ์šฉ ์˜ˆ์‹œ
limiter = RateLimiter(max_requests=10, time_window=60)  # ๋ถ„๋‹น 10 ์š”์ฒญ

def rate_limited_function():
    if not limiter.allow_request():
        raise Exception("๋„ˆ๋ฌด ๋งŽ์€ ์š”์ฒญ์ž…๋‹ˆ๋‹ค. ์ž ์‹œ ํ›„ ๋‹ค์‹œ ์‹œ๋„ํ•ด์ฃผ์„ธ์š”.")
    
    # ์‹ค์ œ ์ž‘์—… ์ˆ˜ํ–‰
    pass
๐Ÿ’ก ๋ณด์•ˆ ์ฒดํฌ๋ฆฌ์ŠคํŠธ:
  • โ˜‘๏ธ ๋ชจ๋“  API ํ‚ค๋Š” ํ™˜๊ฒฝ ๋ณ€์ˆ˜๋กœ ๊ด€๋ฆฌ
  • โ˜‘๏ธ ์‚ฌ์šฉ์ž ์ž…๋ ฅ์€ ํ•ญ์ƒ ๊ฒ€์ฆ ๋ฐ ์ •์ œ
  • โ˜‘๏ธ HTTPS ์‚ฌ์šฉ (ํ”„๋กœ๋•์…˜ ํ™˜๊ฒฝ)
  • โ˜‘๏ธ ์—๋Ÿฌ ๋ฉ”์‹œ์ง€์— ๋ฏผ๊ฐํ•œ ์ •๋ณด ํฌํ•จํ•˜์ง€ ์•Š๊ธฐ
  • โ˜‘๏ธ ๋กœ๊น… ์‹œ ๊ฐœ์ธ์ •๋ณด ๋งˆ์Šคํ‚น
  • โ˜‘๏ธ ์ •๊ธฐ์ ์ธ ์˜์กด์„ฑ ์—…๋ฐ์ดํŠธ
  • โ˜‘๏ธ ๋ ˆ์ดํŠธ ๋ฆฌ๋ฏธํŒ… ๊ตฌํ˜„

๐Ÿš€ ๋ฐฐํฌํ•˜๊ธฐ

๋กœ์ปฌ์—์„œ ์ž˜ ์ž‘๋™ํ•˜๋Š” ์ฑ—๋ด‡์„ ์ด์ œ ์‹ค์ œ๋กœ ๋ฐฐํฌํ•ด๋ณด์ž! ์—ฌ๋Ÿฌ ์˜ต์…˜์ด ์žˆ์–ด. โ˜๏ธ

์˜ต์…˜ 1: Streamlit์œผ๋กœ ์›น ์•ฑ ๋งŒ๋“ค๊ธฐ

๊ฐ€์žฅ ๊ฐ„๋‹จํ•œ ๋ฐฉ๋ฒ•์€ Streamlit์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฑฐ์•ผ:

# app.py
import streamlit as st
from langchain_agent import BlockchainChatbot

st.set_page_config(
    page_title="๋ธ”๋ก์ฒด์ธ AI ์ฑ—๋ด‡",
    page_icon="๐Ÿค–",
    layout="wide"
)

st.title("๐Ÿค–โ›“๏ธ ๋ธ”๋ก์ฒด์ธ AI ์ฑ—๋ด‡")
st.markdown("๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ๋ฅผ ์ž์—ฐ์–ด๋กœ ์งˆ๋ฌธํ•˜์„ธ์š”!")

# ์„ธ์…˜ ์ƒํƒœ ์ดˆ๊ธฐํ™”
if 'chatbot' not in st.session_state:
    with st.spinner("์ฑ—๋ด‡ ์ดˆ๊ธฐํ™” ์ค‘..."):
        st.session_state.chatbot = BlockchainChatbot(network="mainnet")
        st.session_state.messages = []

# ์ฑ„ํŒ… ํžˆ์Šคํ† ๋ฆฌ ํ‘œ์‹œ
for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

# ์‚ฌ์šฉ์ž ์ž…๋ ฅ
if prompt := st.chat_input("์งˆ๋ฌธ์„ ์ž…๋ ฅํ•˜์„ธ์š”..."):
    # ์‚ฌ์šฉ์ž ๋ฉ”์‹œ์ง€ ์ถ”๊ฐ€
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.markdown(prompt)
    
    # ์ฑ—๋ด‡ ์‘๋‹ต
    with st.chat_message("assistant"):
        with st.spinner("์ƒ๊ฐ ์ค‘..."):
            response = st.session_state.chatbot.chat(prompt)
            st.markdown(response)
    
    st.session_state.messages.append({"role": "assistant", "content": response})

# ์‚ฌ์ด๋“œ๋ฐ”
with st.sidebar:
    st.header("โš™๏ธ ์„ค์ •")
    
    if st.button("๋Œ€ํ™” ์ดˆ๊ธฐํ™”"):
        st.session_state.messages = []
        st.session_state.chatbot.memory.clear()
        st.success("๋Œ€ํ™”๊ฐ€ ์ดˆ๊ธฐํ™”๋˜์—ˆ์Šต๋‹ˆ๋‹ค!")
    
    st.markdown("---")
    st.markdown("### ๐Ÿ“š ์‚ฌ์šฉ ๊ฐ€๋Šฅํ•œ ๊ธฐ๋Šฅ")
    st.markdown("""
    - ์ง€๊ฐ‘ ์ž”์•ก ์กฐํšŒ
    - ํŠธ๋žœ์žญ์…˜ ์ •๋ณด ํ™•์ธ
    - ์ตœ์‹  ๋ธ”๋ก ์ •๋ณด
    - ๋ธ”๋ก์ฒด์ธ ์šฉ์–ด ์„ค๋ช…
    """)

์‹คํ–‰ ๋ฐฉ๋ฒ•:

pip install streamlit
streamlit run app.py
์˜ต์…˜ 2: FastAPI๋กœ REST API ๋งŒ๋“ค๊ธฐ

๋‹ค๋ฅธ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์—์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” API๋ฅผ ๋งŒ๋“ค์–ด๋ณด์ž:

# api.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from langchain_agent import BlockchainChatbot
import uvicorn

app = FastAPI(title="Blockchain Chatbot API")

# ์ „์—ญ ์ฑ—๋ด‡ ์ธ์Šคํ„ด์Šค
chatbot = BlockchainChatbot(network="mainnet")

class ChatRequest(BaseModel):
    message: str
    session_id: str = "default"

class ChatResponse(BaseModel):
    response: str
    session_id: str

@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    """์ฑ—๋ด‡๊ณผ ๋Œ€ํ™”"""
    try:
        response = chatbot.chat(request.message)
        return ChatResponse(
            response=response,
            session_id=request.session_id
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health_check():
    """ํ—ฌ์Šค ์ฒดํฌ"""
    return {"status": "healthy"}

@app.post("/reset")
async def reset_conversation():
    """๋Œ€ํ™” ์ดˆ๊ธฐํ™”"""
    chatbot.memory.clear()
    return {"message": "๋Œ€ํ™”๊ฐ€ ์ดˆ๊ธฐํ™”๋˜์—ˆ์Šต๋‹ˆ๋‹ค."}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

์‹คํ–‰:

pip install fastapi uvicorn
python api.py
์˜ต์…˜ 3: Docker๋กœ ์ปจํ…Œ์ด๋„ˆํ™”

์–ด๋””์„œ๋“  ์‰ฝ๊ฒŒ ๋ฐฐํฌํ•  ์ˆ˜ ์žˆ๋„๋ก Docker ์ด๋ฏธ์ง€๋ฅผ ๋งŒ๋“ค์ž:

# Dockerfile
FROM python:3.10-slim

WORKDIR /app

# ์˜์กด์„ฑ ์„ค์น˜
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜ ์ฝ”๋“œ ๋ณต์‚ฌ
COPY . .

# ํ™˜๊ฒฝ ๋ณ€์ˆ˜ (์‹ค์ œ๋กœ๋Š” docker-compose๋‚˜ k8s์—์„œ ์ฃผ์ž…)
ENV OPENAI_API_KEY=""
ENV INFURA_API_KEY=""
ENV ETHERSCAN_API_KEY=""

# ํฌํŠธ ๋…ธ์ถœ
EXPOSE 8000

# ์‹คํ–‰
CMD ["python", "api.py"]
# docker-compose.yml
version: '3.8'

services:
  chatbot:
    build: .
    ports:
      - "8000:8000"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - INFURA_API_KEY=${INFURA_API_KEY}
      - ETHERSCAN_API_KEY=${ETHERSCAN_API_KEY}
    volumes:
      - ./chroma_db:/app/chroma_db
    restart: unless-stopped

์‹คํ–‰:

docker-compose up -d
๐Ÿ’ก ๋ฐฐํฌ ํ”Œ๋žซํผ ์ถ”์ฒœ: โ€ข Streamlit Cloud: Streamlit ์•ฑ ๋ฌด๋ฃŒ ํ˜ธ์ŠคํŒ…
โ€ข Railway: ๊ฐ„๋‹จํ•œ ๋ฐฐํฌ, ๋ฌด๋ฃŒ ํ‹ฐ์–ด ์ œ๊ณต
โ€ข Render: Docker ์ง€์›, ์ž๋™ ๋ฐฐํฌ
โ€ข AWS/GCP/Azure: ํ”„๋กœ๋•์…˜ ๋ ˆ๋ฒจ ๋ฐฐํฌ
โ€ข Vercel: Next.js์™€ ํ•จ๊ป˜ ์‚ฌ์šฉ ์‹œ ์ข‹์Œ

๐Ÿ› ๋””๋ฒ„๊น…๊ณผ ๋ฌธ์ œ ํ•ด๊ฒฐ

๊ฐœ๋ฐœํ•˜๋‹ค ๋ณด๋ฉด ์—ฌ๋Ÿฌ ๋ฌธ์ œ์— ๋ถ€๋”ชํžˆ๊ฒŒ ๋ผ. ์ž์ฃผ ๋ฐœ์ƒํ•˜๋Š” ๋ฌธ์ œ๋“ค๊ณผ ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•์„ ์ •๋ฆฌํ•ด๋ดค์–ด. ๐Ÿ”ง

โŒ ๋ฌธ์ œ 1: "Failed to connect to Ethereum network" ์›์ธ: Infura API ํ‚ค๊ฐ€ ์ž˜๋ชป๋˜์—ˆ๊ฑฐ๋‚˜, ๋„คํŠธ์›Œํฌ ์—ฐ๊ฒฐ ๋ฌธ์ œ

ํ•ด๊ฒฐ:
1. .env ํŒŒ์ผ์˜ INFURA_API_KEY ํ™•์ธ
2. Infura ๋Œ€์‹œ๋ณด๋“œ์—์„œ ํ”„๋กœ์ ํŠธ ์ƒํƒœ ํ™•์ธ
3. ๋„คํŠธ์›Œํฌ ์ด๋ฆ„ ํ™•์ธ (mainnet, goerli, sepolia ๋“ฑ)
4. ๋ฐฉํ™”๋ฒฝ ์„ค์ • ํ™•์ธ
โŒ ๋ฌธ์ œ 2: "Rate limit exceeded" ์›์ธ: API ํ˜ธ์ถœ ํ•œ๋„ ์ดˆ๊ณผ

ํ•ด๊ฒฐ:
1. ์บ์‹ฑ ๊ตฌํ˜„
2. ์š”์ฒญ ๊ฐ„ ๋”œ๋ ˆ์ด ์ถ”๊ฐ€
3. ์œ ๋ฃŒ ํ”Œ๋žœ์œผ๋กœ ์—…๊ทธ๋ ˆ์ด๋“œ
4. ์—ฌ๋Ÿฌ API ํ‚ค ๋กœํ…Œ์ด์…˜
โŒ ๋ฌธ์ œ 3: "Invalid address format" ์›์ธ: ์ž˜๋ชป๋œ ์ด๋”๋ฆฌ์›€ ์ฃผ์†Œ ํ˜•์‹

ํ•ด๊ฒฐ:
1. ์ฃผ์†Œ๊ฐ€ 0x๋กœ ์‹œ์ž‘ํ•˜๋Š”์ง€ ํ™•์ธ
2. 42์ž๋ฆฌ 16์ง„์ˆ˜์ธ์ง€ ํ™•์ธ
3. Web3.to_checksum_address() ์‚ฌ์šฉ
4. ์ž…๋ ฅ ๊ฒ€์ฆ ๋กœ์ง ์ถ”๊ฐ€
โŒ ๋ฌธ์ œ 4: "OpenAI API error" ์›์ธ: OpenAI API ํ‚ค ๋ฌธ์ œ ๋˜๋Š” ํ• ๋‹น๋Ÿ‰ ์ดˆ๊ณผ

ํ•ด๊ฒฐ:
1. API ํ‚ค ์œ ํšจ์„ฑ ํ™•์ธ
2. ์‚ฌ์šฉ๋Ÿ‰ ํ™•์ธ (platform.openai.com)
3. ๊ฒฐ์ œ ์ •๋ณด ํ™•์ธ
4. ๋ชจ๋ธ ์ด๋ฆ„ ํ™•์ธ (gpt-4, gpt-3.5-turbo ๋“ฑ)

๋กœ๊น…์„ ์ถ”๊ฐ€ํ•˜๋ฉด ๋””๋ฒ„๊น…์ด ํ›จ์”ฌ ์‰ฌ์›Œ์ ธ:

import logging

# ๋กœ๊น… ์„ค์ •
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('chatbot.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)

# ์‚ฌ์šฉ ์˜ˆ์‹œ
def get_balance(self, address: str):
    logger.info(f"Fetching balance for address: {address}")
    try:
        result = self._fetch_balance(address)
        logger.info(f"Successfully fetched balance: {result}")
        return result
    except Exception as e:
        logger.error(f"Error fetching balance: {str(e)}", exc_info=True)
        raise

๐Ÿ“ˆ ํ™•์žฅ ์•„์ด๋””์–ด

๊ธฐ๋ณธ ์ฑ—๋ด‡์„ ๋งŒ๋“ค์—ˆ์œผ๋‹ˆ, ์ด์ œ ๋” ๋ฐœ์ „์‹œ์ผœ๋ณผ ์ˆ˜ ์žˆ์–ด! ๋ช‡ ๊ฐ€์ง€ ํ™•์žฅ ์•„์ด๋””์–ด๋ฅผ ์†Œ๊ฐœํ• ๊ฒŒ. ๐Ÿ’ก

๐ŸŽจ NFT ๋ถ„์„ ๊ธฐ๋Šฅ โ€ข OpenSea API ์—ฐ๋™
โ€ข NFT ๋ฉ”ํƒ€๋ฐ์ดํ„ฐ ์กฐํšŒ
โ€ข ๊ฐ€๊ฒฉ ์ถ”์ด ๋ถ„์„
โ€ข ํฌ๊ท€๋„ ๊ณ„์‚ฐ
โ€ข ์ปฌ๋ ‰์…˜ ํ†ต๊ณ„
๐Ÿ’ฑ DeFi ํ”„๋กœํ† ์ฝœ ์—ฐ๋™ โ€ข Uniswap ๊ฐ€๊ฒฉ ์กฐํšŒ
โ€ข ์œ ๋™์„ฑ ํ’€ ์ •๋ณด
โ€ข ์Šคํ…Œ์ดํ‚น ์ˆ˜์ต๋ฅ 
โ€ข ๋Œ€์ถœ/์ฐจ์ž… ์ •๋ณด
โ€ข ๊ฐ€์Šค๋น„ ์ตœ์ ํ™” ์ œ์•ˆ
๐Ÿ“Š ๊ณ ๊ธ‰ ๋ถ„์„ โ€ข ์ง€๊ฐ‘ ํ”„๋กœํŒŒ์ผ๋ง
โ€ข ๊ฑฐ๋ž˜ ํŒจํ„ด ๋ถ„์„
โ€ข ๋„คํŠธ์›Œํฌ ๊ทธ๋ž˜ํ”„
โ€ข ์ด์ƒ ๊ฑฐ๋ž˜ ํƒ์ง€
โ€ข ์˜ˆ์ธก ๋ชจ๋ธ๋ง
๐ŸŒ ๋ฉ€ํ‹ฐ์ฒด์ธ ์ง€์› โ€ข Polygon ์—ฐ๋™
โ€ข BSC ์ง€์›
โ€ข Solana ํ†ตํ•ฉ
โ€ข ํฌ๋กœ์Šค์ฒด์ธ ์ถ”์ 
โ€ข ์ฒด์ธ๋ณ„ ๋น„๊ต
๐ŸŽฏ ์‹ค์ „ ํ”„๋กœ์ ํŠธ ์•„์ด๋””์–ด 1. ํฌํŠธํด๋ฆฌ์˜ค ํŠธ๋ž˜์ปค: ์—ฌ๋Ÿฌ ์ง€๊ฐ‘์˜ ์ž์‚ฐ์„ ํ†ตํ•ฉ ๊ด€๋ฆฌํ•˜๊ณ  ์‹ค์‹œ๊ฐ„์œผ๋กœ ๊ฐ€์น˜๋ฅผ ์ถ”์ 

2. ์Šค๋งˆํŠธ ์•Œ๋ฆผ ์‹œ์Šคํ…œ: ํŠน์ • ์กฐ๊ฑด์ด ๋งŒ์กฑ๋˜๋ฉด ์•Œ๋ฆผ (์˜ˆ: ๊ณ ๋ž˜ ์ง€๊ฐ‘ ์›€์ง์ž„, ๊ฐ€๊ฒฉ ๋ณ€๋™)

3. ์„ธ๊ธˆ ๊ณ„์‚ฐ๊ธฐ: ๊ฑฐ๋ž˜ ๋‚ด์—ญ์„ ๋ถ„์„ํ•ด์„œ ์„ธ๊ธˆ ๋ณด๊ณ ์„œ ์ž๋™ ์ƒ์„ฑ

4. ๊ต์œก ํ”Œ๋žซํผ: ๋ธ”๋ก์ฒด์ธ ์ดˆ๋ณด์ž๋ฅผ ์œ„ํ•œ ๋Œ€ํ™”ํ˜• ํ•™์Šต ๋„๊ตฌ

5. ๊ฐ์‚ฌ ๋„๊ตฌ: ์Šค๋งˆํŠธ ์ปจํŠธ๋ž™ํŠธ ๋ณด์•ˆ ๋ถ„์„ ๋ฐ ์ทจ์•ฝ์  ํƒ์ง€

์ด๋Ÿฐ ๊ธฐ๋Šฅ๋“ค์„ ์ถ”๊ฐ€ํ•˜๋ฉด ๋‹จ์ˆœํ•œ ์ฑ—๋ด‡์„ ๋„˜์–ด์„œ ์‹ค์ œ๋กœ ์œ ์šฉํ•œ ๋ธ”๋ก์ฒด์ธ ๋ถ„์„ ํ”Œ๋žซํผ์œผ๋กœ ๋ฐœ์ „์‹œํ‚ฌ ์ˆ˜ ์žˆ์–ด! ๐Ÿš€

ํ˜น์‹œ ์ด๋Ÿฐ ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ ๊ตฌํ˜„์— ๋„์›€์ด ํ•„์š”ํ•˜๋‹ค๋ฉด, ์žฌ๋Šฅ๋„ท์—์„œ ๋ธ”๋ก์ฒด์ธ๊ณผ AI ์ „๋ฌธ๊ฐ€๋“ค์„ ์ฐพ์•„๋ณผ ์ˆ˜ ์žˆ์–ด. ์‹ค๋ฌด ๊ฒฝํ—˜์ด ํ’๋ถ€ํ•œ ๊ฐœ๋ฐœ์ž๋“ค์˜ ๋ฉ˜ํ† ๋ง์ด๋‚˜ ์ฝ”๋“œ ๋ฆฌ๋ทฐ๋ฅผ ๋ฐ›์œผ๋ฉด ํ”„๋กœ์ ํŠธ ํ€„๋ฆฌํ‹ฐ๋ฅผ ํ•œ ๋‹จ๊ณ„ ๋†’์ผ ์ˆ˜ ์žˆ๊ฑฐ๋“ !


๐Ÿ’ฐ ์ˆ˜์ตํ™” ์ „๋žต

์ข‹์€ ํ”„๋กœ์ ํŠธ๋ฅผ ๋งŒ๋“ค์—ˆ๋‹ค๋ฉด ์ˆ˜์ตํ™”๋„ ๊ณ ๋ คํ•ด๋ณผ ์ˆ˜ ์žˆ์–ด. ๋ช‡ ๊ฐ€์ง€ ๋ฐฉ๋ฒ•์„ ์†Œ๊ฐœํ• ๊ฒŒ. ๐Ÿ’ธ

๐Ÿ“Š ํ”„๋ฆฌ๋ฏธ์—„ ๋ชจ๋ธ ๋ฌด๋ฃŒ ํ‹ฐ์–ด:
โ€ข ๊ธฐ๋ณธ ์ž”์•ก ์กฐํšŒ
โ€ข ์ผ์ผ 10ํšŒ ์งˆ๋ฌธ ์ œํ•œ
โ€ข ์ตœ๊ทผ 10๊ฐœ ํŠธ๋žœ์žญ์…˜๋งŒ ์กฐํšŒ

ํ”„๋ฆฌ๋ฏธ์—„ ํ‹ฐ์–ด ($9.99/์›”):
โ€ข ๋ฌด์ œํ•œ ์งˆ๋ฌธ
โ€ข ๊ณ ๊ธ‰ ๋ถ„์„ ๊ธฐ๋Šฅ
โ€ข ์‹ค์‹œ๊ฐ„ ์•Œ๋ฆผ
โ€ข API ์•ก์„ธ์Šค
โ€ข ์šฐ์„  ์ง€์›

์—”ํ„ฐํ”„๋ผ์ด์ฆˆ ํ‹ฐ์–ด (๋งž์ถค ๊ฐ€๊ฒฉ):
โ€ข ์ „์šฉ ์ธ์Šคํ„ด์Šค
โ€ข ์ปค์Šคํ…€ ๊ธฐ๋Šฅ
โ€ข SLA ๋ณด์žฅ
โ€ข ์ „๋‹ด ์ง€์›ํŒ€
๐Ÿ”Œ API ์„œ๋น„์Šค ๋‹ค๋ฅธ ๊ฐœ๋ฐœ์ž๋“ค์ด ๋‹น์‹ ์˜ ์ฑ—๋ด‡์„ ์ž์‹ ์˜ ์•ฑ์— ํ†ตํ•ฉํ•  ์ˆ˜ ์žˆ๊ฒŒ API๋ฅผ ์ œ๊ณต:

โ€ข ์š”์ฒญ๋‹น ๊ณผ๊ธˆ ($0.01/request)
โ€ข ์›”๊ฐ„ ๊ตฌ๋… ($49/์›” - 10,000 requests)
โ€ข ํ™”์ดํŠธ๋ผ๋ฒจ ์†”๋ฃจ์…˜ ์ œ๊ณต
๐ŸŽ“ ๊ต์œก ์ฝ˜ํ…์ธ  โ€ข ์˜จ๋ผ์ธ ๊ฐ•์˜ ํŒ๋งค
โ€ข 1:1 ๋ฉ˜ํ† ๋ง
โ€ข ๊ธฐ์—… ๊ต์œก ํ”„๋กœ๊ทธ๋žจ
โ€ข ์ „์ž์ฑ… ์ถœํŒ
๐Ÿ’ก ์ˆ˜์ตํ™” ํŒ: ์ฒ˜์Œ๋ถ€ํ„ฐ ์œ ๋ฃŒํ™”ํ•˜์ง€ ๋ง๊ณ , ๋จผ์ € ์‚ฌ์šฉ์ž ๋ฒ ์ด์Šค๋ฅผ ๊ตฌ์ถ•ํ•ด. ๋ฌด๋ฃŒ ๋ฒ„์ „์œผ๋กœ ๊ฐ€์น˜๋ฅผ ์ฆ๋ช…ํ•œ ๋‹ค์Œ, ํ”„๋ฆฌ๋ฏธ์—„ ๊ธฐ๋Šฅ์„ ์ถ”๊ฐ€ํ•˜๋Š” ๊ฒŒ ์ข‹์•„. ๊ทธ๋ฆฌ๊ณ  ์‚ฌ์šฉ์ž ํ”ผ๋“œ๋ฐฑ์„ ์ ๊ทน ๋ฐ˜์˜ํ•ด์„œ ์‹ค์ œ๋กœ ํ•„์š”ํ•œ ๊ธฐ๋Šฅ์„ ๋งŒ๋“œ๋Š” ๊ฒŒ ์ค‘์š”ํ•ด!

๐ŸŽ“ ํ•™์Šต ๋ฆฌ์†Œ์Šค

๋” ๊นŠ์ด ๊ณต๋ถ€ํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด ์ด๋Ÿฐ ๋ฆฌ์†Œ์Šค๋“ค์„ ์ถ”์ฒœํ•ด. ๐Ÿ“š

๐Ÿ“– ๊ณต์‹ ๋ฌธ์„œ โ€ข LangChain: python.langchain.com/docs
โ€ข Web3.py: web3py.readthedocs.io
โ€ข OpenAI: platform.openai.com/docs
โ€ข Ethereum: ethereum.org/developers
๐ŸŽฅ ์˜จ๋ผ์ธ ๊ฐ•์˜ โ€ข Udemy: "Blockchain Development"
โ€ข Coursera: "Blockchain Specialization"
โ€ข YouTube: Patrick Collins, Dapp University
โ€ข freeCodeCamp: Solidity ํŠœํ† ๋ฆฌ์–ผ
๐Ÿ‘ฅ ์ปค๋ฎค๋‹ˆํ‹ฐ โ€ข Reddit: r/ethdev, r/LangChain
โ€ข Discord: LangChain, Ethereum
โ€ข Stack Overflow: ethereum, web3
โ€ข GitHub: ์˜คํ”ˆ์†Œ์Šค ํ”„๋กœ์ ํŠธ ์ฐธ์—ฌ
๐Ÿ“ฐ ๋‰ด์Šค/๋ธ”๋กœ๊ทธ โ€ข CoinDesk, The Block (๋ธ”๋ก์ฒด์ธ ๋‰ด์Šค)
โ€ข Towards Data Science (AI/ML)
โ€ข Medium: LangChain, Web3 ํƒœ๊ทธ
โ€ข Dev.to: ๊ฐœ๋ฐœ์ž ๋ธ”๋กœ๊ทธ

๐ŸŽฏ ๋งˆ๋ฌด๋ฆฌํ•˜๋ฉฐ

์™€, ์—ฌ๊ธฐ๊นŒ์ง€ ์ •๋ง ๊ธด ์—ฌ์ •์ด์—ˆ์–ด! ๐ŸŽ‰

์šฐ๋ฆฌ๋Š” ํŒŒ์ด์ฌ๊ณผ ๋žญ์ฒด์ธ์„ ์‚ฌ์šฉํ•ด์„œ ๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ๋ฅผ ํ•ด์„ํ•˜๋Š” AI ์ฑ—๋ด‡์„ ์ฒ˜์Œ๋ถ€ํ„ฐ ๋๊นŒ์ง€ ๋งŒ๋“ค์–ด๋ดค์–ด. ๋ธ”๋ก์ฒด์ธ ์—ฐ๊ฒฐ๋ถ€ํ„ฐ LangChain ์—์ด์ „ํŠธ ๊ตฌ์ถ•, ์‚ฌ์šฉ์ž ์ธํ„ฐํŽ˜์ด์Šค, ๋ณด์•ˆ, ๋ฐฐํฌ๊นŒ์ง€ ์ „ ๊ณผ์ •์„ ๋‹ค๋ค˜์ง€.

๐ŸŽ“ ์šฐ๋ฆฌ๊ฐ€ ๋ฐฐ์šด ๊ฒƒ๋“ค:
  • โœ… Web3.py๋กœ ๋ธ”๋ก์ฒด์ธ ๋ฐ์ดํ„ฐ ์กฐํšŒํ•˜๊ธฐ
  • โœ… LangChain์œผ๋กœ AI ์—์ด์ „ํŠธ ๋งŒ๋“ค๊ธฐ
  • โœ… ๋„๊ตฌ(Tools)๋ฅผ ์ •์˜ํ•˜๊ณ  AI๊ฐ€ ์„ ํƒํ•˜๊ฒŒ ํ•˜๊ธฐ
  • โœ… ๋Œ€ํ™” ๋ฉ”๋ชจ๋ฆฌ์™€ ์ปจํ…์ŠคํŠธ ๊ด€๋ฆฌ
  • โœ… ๋ฒกํ„ฐ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค๋กœ ์ง€์‹ ์ €์žฅํ•˜๊ธฐ
  • โœ… ์„ฑ๋Šฅ ์ตœ์ ํ™”์™€ ์บ์‹ฑ ์ „๋žต
  • โœ… ๋ณด์•ˆ ๊ณ ๋ ค์‚ฌํ•ญ
  • โœ… ์‹ค์ „ ๋ฐฐํฌ ๋ฐฉ๋ฒ•

์ด์ œ ๋‹น์‹ ์€ ๋ธ”๋ก์ฒด์ธ๊ณผ AI๋ฅผ ๊ฒฐํ•ฉํ•œ ์‹ค์šฉ์ ์ธ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š” ๋Šฅ๋ ฅ์„ ๊ฐ–์ท„์–ด! ๐Ÿ’ช

ํ•˜์ง€๋งŒ ์ด๊ฑด ์‹œ์ž‘์ผ ๋ฟ์ด์•ผ. ์—ฌ๊ธฐ์„œ ๋ฐฐ์šด ๊ธฐ์ˆ ๋“ค์„ ๋ฐ”ํƒ•์œผ๋กœ ๋” ์ฐฝ์˜์ ์ด๊ณ  ํ˜์‹ ์ ์ธ ํ”„๋กœ์ ํŠธ๋ฅผ ๋งŒ๋“ค์–ด๋ณผ ์ˆ˜ ์žˆ์–ด. NFT ๋ถ„์„ ๋„๊ตฌ, DeFi ๋Œ€์‹œ๋ณด๋“œ, ์Šค๋งˆํŠธ ์ปจํŠธ๋ž™ํŠธ ๊ฐ์‚ฌ ๋„๊ตฌ... ๊ฐ€๋Šฅ์„ฑ์€ ๋ฌด๊ถ๋ฌด์ง„ํ•ด!

๐Ÿ’ก ๋‹ค์Œ ๋‹จ๊ณ„: 1. ์ด ํŠœํ† ๋ฆฌ์–ผ์˜ ์ฝ”๋“œ๋ฅผ ์ง์ ‘ ์‹คํ–‰ํ•ด๋ณด๊ธฐ
2. ์ž์‹ ๋งŒ์˜ ๊ธฐ๋Šฅ ์ถ”๊ฐ€ํ•ด๋ณด๊ธฐ
3. ์‹ค์ œ ํ”„๋กœ์ ํŠธ์— ์ ์šฉํ•ด๋ณด๊ธฐ
4. ์ปค๋ฎค๋‹ˆํ‹ฐ์— ๊ณต์œ ํ•˜๊ณ  ํ”ผ๋“œ๋ฐฑ ๋ฐ›๊ธฐ
5. ์˜คํ”ˆ์†Œ์Šค๋กœ ๊ณต๊ฐœํ•˜๊ฑฐ๋‚˜ ์ƒ์šฉํ™” ๊ณ ๋ คํ•˜๊ธฐ

๋ธ”๋ก์ฒด์ธ๊ณผ AI๋Š” ์•ž์œผ๋กœ ๋”์šฑ ์ค‘์š”ํ•ด์งˆ ๊ธฐ์ˆ ์ด์•ผ. ์ง€๊ธˆ ๋ฐฐ์šด ๊ฒƒ๋“ค์ด ๋ฏธ๋ž˜์˜ ์ปค๋ฆฌ์–ด์— ํฐ ๋„์›€์ด ๋  ๊ฑฐ๋ผ๊ณ  ํ™•์‹ ํ•ด. ๐Ÿš€

ํ˜น์‹œ ํ”„๋กœ์ ํŠธ๋ฅผ ์ง„ํ–‰ํ•˜๋‹ค๊ฐ€ ๋ง‰ํžˆ๋Š” ๋ถ€๋ถ„์ด ์žˆ๊ฑฐ๋‚˜, ๋” ์ „๋ฌธ์ ์ธ ์กฐ์–ธ์ด ํ•„์š”ํ•˜๋‹ค๋ฉด ์ฃผ์ €ํ•˜์ง€ ๋ง๊ณ  ๋„์›€์„ ๊ตฌํ•ด. ๊ฐœ๋ฐœ์ž ์ปค๋ฎค๋‹ˆํ‹ฐ๋Š” ํ•ญ์ƒ ์—ด๋ ค์žˆ๊ณ , ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ๋Š” ์‹ค๋ฌด ์ „๋ฌธ๊ฐ€๋“ค์˜ ๋ฉ˜ํ† ๋ง๋„ ๋ฐ›์„ ์ˆ˜ ์žˆ์–ด.

์ž, ์ด์ œ ๋‹น์‹  ์ฐจ๋ก€์•ผ! ์˜ค๋Š˜ ๋ฐฐ์šด ๊ฒƒ๋“ค์„ ๋ฐ”ํƒ•์œผ๋กœ ๋ฉ‹์ง„ ํ”„๋กœ์ ํŠธ๋ฅผ ๋งŒ๋“ค์–ด๋ด. ๊ทธ๋ฆฌ๊ณ  ์–ธ์  ๊ฐ€ ๋‹น์‹ ์ด ๋งŒ๋“  ๋ธ”๋ก์ฒด์ธ AI ์ฑ—๋ด‡์ด ๋งŽ์€ ์‚ฌ๋žŒ๋“ค์—๊ฒŒ ๋„์›€์„ ์ฃผ๋Š” ๋‚ ์ด ์˜ค๊ธฐ๋ฅผ ๊ธฐ๋Œ€ํ• ๊ฒŒ! โœจ

Happy Coding! ๐ŸŽ‰๐Ÿš€๐Ÿ’ป

Thank You! Keep Building Amazing Things
๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.