Ver3.0 ๐คโ๏ธ ํ์ด์ฌ๊ณผ ๋ญ์ฒด์ธ์ผ๋ก AI ๋ธ๋ก์ฒด์ธ ํด์ ์ฑ๋ด ๋ง๋ค๊ธฐ

๐คโ๏ธ ํ์ด์ฌ๊ณผ ๋ญ์ฒด์ธ์ผ๋ก AI ๋ธ๋ก์ฒด์ธ ํด์ ์ฑ๋ด ๋ง๋ค๊ธฐ
๋ธ๋ก์ฒด์ธ ๋ฐ์ดํฐ๋ฅผ ๋๋ํ๊ฒ ๋ถ์ํ๋ AI ์ฑ๋ด, ์ง์ ๋ง๋ค์ด๋ณด์! ๐
์๋
, ์น๊ตฌ! ๐ ์์ฆ ๋ธ๋ก์ฒด์ธ์ด๋ AI๊ฐ ๋์ธ์์? ๊ทผ๋ฐ ์ด ๋์ ํฉ์น๋ฉด ๋ญ๊ฐ ์์ฒญ๋ ๊ฑธ ๋ง๋ค ์ ์์ ๊ฒ ๊ฐ์ง ์์? ์ค๋์ ๋ฐ๋ก ๊ทธ ์ด์ผ๊ธฐ๋ฅผ ํด๋ณด๋ ค๊ณ ํด. ๐ฏ
๋ธ๋ก์ฒด์ธ ๋ฐ์ดํฐ๋ ์์งํ ๋งํ๋ฉด ์ข ๋ณต์กํด. ํธ๋์ญ์
ํด์, ์ค๋งํธ ์ปจํธ๋ํธ ์ฃผ์, ๊ฐ์ค๋น... ์ด๋ฐ ๊ฑฐ ๋ณด๋ฉด ๋จธ๋ฆฌ๊ฐ ์ง๋์ง๋ํ์์? ๊ทธ๋ฐ๋ฐ ๋ง์ฝ ์ด ๋ชจ๋ ๊ฑธ ์์ฐ์ด๋ก ๋ฌผ์ด๋ณด๋ฉด AI๊ฐ ์ฒ์ฒ ๋๋ตํด์ฃผ๋ ์ฑ๋ด์ด ์๋ค๋ฉด? ๐ค
๋ฐ๋ก ๊ทธ๊ฑธ ๋ง๋ค์ด๋ณผ ๊ฑฐ์ผ! ํ์ด์ฌ๊ณผ ๋ญ์ฒด์ธ(LangChain)์ ํ์ฉํด์ ๋ธ๋ก์ฒด์ธ ๋ฐ์ดํฐ๋ฅผ ํด์ํ๋ ๋๋ํ AI ์ฑ๋ด์ ์ง์ ๊ตฌ์ถํด๋ณด์๊ณ . ์ฝ๋ฉ ๊ฒฝํ์ด ์ข ์๋ค๋ฉด ์ถฉ๋ถํ ๋ฐ๋ผ์ฌ ์ ์์ ๊ฑฐ์ผ!
๐ช ์ ๋ธ๋ก์ฒด์ธ ํด์ ์ฑ๋ด์ด ํ์ํ ๊น?
๋จผ์ ์ด ํ๋ก์ ํธ๊ฐ ์ ์๋ฏธ ์๋์ง๋ถํฐ ์ด์ผ๊ธฐํด๋ณผ๊ฒ. ๐ก
๋ธ๋ก์ฒด์ธ ์ํ๊ณ๋ ์์ฒญ๋๊ฒ ๋น ๋ฅด๊ฒ ์ฑ์ฅํ๊ณ ์์ด. ์ด๋๋ฆฌ์, ๋นํธ์ฝ์ธ, ์๋ผ๋, ํด๋ฆฌ๊ณค... ์๋ง์ ์ฒด์ธ๋ค์ด ์๊ณ , ๋งค์ผ ์๋ฐฑ๋ง ๊ฑด์ ํธ๋์ญ์
์ด ๋ฐ์ํ์ง. ๊ทธ๋ฐ๋ฐ ๋ฌธ์ ๋ ์ด ๋ฐ์ดํฐ๋ค์ด ์ผ๋ฐ ์ฌ์ฉ์๋ค์๊ฒ๋ ๋๋ฌด ์ด๋ ต๋ค๋ ๊ฑฐ์ผ.
2. ๊ฐ๋ฐ์๋ค: "์ด ์ค๋งํธ ์ปจํธ๋ํธ์ ํจ์ ํธ์ถ ํจํด์ ๋ถ์ํด์ค"
3. ๊ฐ์ฌ๊ด๋ค: "์์ฌ์ค๋ฌ์ด ํธ๋์ญ์ ํจํด์ ์ฐพ์์ค"
4. ์ผ๋ฐ ์ฌ์ฉ์: "๋ด NFT ๊ฑฐ๋ ๋ด์ญ์ ์ฝ๊ฒ ์ค๋ช ํด์ค"
์ด๋ฐ ์ง๋ฌธ๋ค์ ๋๋ตํ๋ ค๋ฉด ๋ณดํต ๋ธ๋ก ์ต์คํ๋ก๋ฌ๋ฅผ ๋ค์ง๊ณ , ๋ณต์กํ ์ฟผ๋ฆฌ๋ฅผ ์์ฑํ๊ณ , ๋ฐ์ดํฐ๋ฅผ ๋ถ์ํด์ผ ํด. ํ์ง๋ง AI ์ฑ๋ด์ด ์๋ค๋ฉด? ๊ทธ๋ฅ ๋ฌผ์ด๋ณด๊ธฐ๋ง ํ๋ฉด ๋ผ! โจ
๐ ๏ธ ํ์ํ ๋๊ตฌ๋ค๊ณผ ๊ธฐ์ ์คํ
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์์ํด๋ณผ๊น? ๋จผ์ ์ฐ๋ฆฌ๊ฐ ์ฌ์ฉํ ๋๊ตฌ๋ค์ ์ดํด๋ณด์. ๐งฐ
์ถ๊ฐ๋ก ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค๋ ์์ด:
โข requests: API ํธ์ถ์ฉ
โข pandas: ๋ฐ์ดํฐ ์ฒ๋ฆฌ์ฉ
โข python-dotenv: ํ๊ฒฝ ๋ณ์ ๊ด๋ฆฌ์ฉ
โข chromadb: ๋ฒกํฐ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ฉ (์ ํ์ฌํญ)
๐ฆ ํ๊ฒฝ ์ค์ ํ๊ธฐ
์, ์ด์ ์ค์ ๋ก ์์ ๋๋ฝํ๋ณผ ์๊ฐ์ด์ผ! ๐ป ๋จผ์ ๊ฐ๋ฐ ํ๊ฒฝ์ ์ธํ ํด๋ณด์.
ํ๋ก์ ํธ ํด๋๋ฅผ ๋ง๋ค๊ณ ๊ฐ์ํ๊ฒฝ์ ์ค์ ํ์. ์ด๋ ๊ฒ ํ๋ฉด ํจํค์ง ์ถฉ๋์ ๋ฐฉ์งํ ์ ์์ด.
mkdir blockchain-chatbot
cd blockchain-chatbot
python -m venv venv
# Windows
venv\Scripts\activate
# Mac/Linux
source venv/bin/activate
์ด์ ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ ์ค์นํด๋ณด์.
pip install langchain openai web3 python-dotenv requests pandas chromadb
ํ๋ก์ ํธ ๋ฃจํธ์ .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
API ํค๋ฅผ ์ด๋์ ๋ฐ๋๊ณ ? ๐
โข OpenAI: platform.openai.com์์ ๊ณ์ ๋ง๋ค๊ณ ๋ฐ๊ธ
โข Infura: infura.io์์ ๋ฌด๋ฃ ๊ณ์ ์์ฑ (์ด๋๋ฆฌ์ ๋
ธ๋ ์ ๊ทผ์ฉ)
โข Etherscan: etherscan.io์์ ๋ฌด๋ฃ API ํค ๋ฐ๊ธ (ํธ๋์ญ์
์กฐํ์ฉ)
๐๏ธ ๊ธฐ๋ณธ ์ํคํ ์ฒ ์ค๊ณ
์ฝ๋๋ฅผ ์์ฑํ๊ธฐ ์ ์ ์ ์ฒด ์์คํ ๊ตฌ์กฐ๋ฅผ ์ดํดํ๋ ๊ฒ ์ค์ํด. ์ฐ๋ฆฌ ์ฑ๋ด์ ํฌ๊ฒ 4๊ฐ์ ๋ ์ด์ด๋ก ๊ตฌ์ฑ๋ ๊ฑฐ์ผ. ๐จ
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)}
์ด์ ์ด ์ปค๋ฅํฐ๋ฅผ ํ ์คํธํด๋ณด์:
# 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)}"
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๊ฐ ์ดํดํด
โข ์ด์ ๋ํ ๋งฅ๋ฝ์ ๊ธฐ์ตํ๋๊น ์ฐ์๋ ์ง๋ฌธ๋ ๊ฐ๋ฅํด
โข ๋ชจ๋ฅด๋ ๋ธ๋ก์ฒด์ธ ์ฉ์ด๊ฐ ์์ผ๋ฉด ๊ทธ๋ฅ ๋ฌผ์ด๋ด!
์ค์ ์ฌ์ฉ ์์๋ฅผ ๋ณด์๋ฉด: ๐ญ
๐ค Chatbot: ํ์ฌ ์ด๋๋ฆฌ์ ๋ฉ์ธ๋ท์ ์ต์ ๋ธ๋ก์ #18,500,123์ ๋๋ค. ์ด ๋ธ๋ก์๋ 150๊ฐ์ ํธ๋์ญ์ ์ด ํฌํจ๋์ด ์์ผ๋ฉฐ...
๐ค You: ๊ทธ ๋ธ๋ก์ ๊ฐ์ค๋น๋ ์ด๋ป๊ฒ ๋ผ?
๐ค Chatbot: ํด๋น ๋ธ๋ก์์ ์ฌ์ฉ๋ ์ด ๊ฐ์ค๋ 15,000,000 ๊ฐ์ค์ ๋๋ค. ๋ธ๋ก ๊ฐ์ค ํ๋๋ 30,000,000์ด๋ฏ๋ก ์ฝ 50%๊ฐ ์ฌ์ฉ๋์๋ค์...
๐ ๊ณ ๊ธ ๊ธฐ๋ฅ ์ถ๊ฐํ๊ธฐ
๊ธฐ๋ณธ ๊ธฐ๋ฅ์ ์์ฑํ์ด! ์ด์ ์ข ๋ ๊ณ ๊ธ ๊ธฐ๋ฅ๋ค์ ์ถ๊ฐํด๋ณด์. โก
์ค๋งํธ ์ปจํธ๋ํธ์ ํจ์๋ฅผ ํธ์ถํ๊ณ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ์ ์๋ ๊ธฐ๋ฅ์ ์ถ๊ฐํด๋ณด์.
# 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)}
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
โข ํ์ฅ ๊ฐ๋ฅ: ์๋ก์ด ์ง์์ ๊ณ์ ์ถ๊ฐํ ์ ์์ด
โข ๋น ๋ฅธ ๊ฒ์: ์์ฒ ๊ฐ์ ๋ฌธ์์์๋ ๋น ๋ฅด๊ฒ ๊ด๋ จ ์ ๋ณด๋ฅผ ์ฐพ์
โข ๋งฅ๋ฝ ์ดํด: ๋จ์ ํค์๋ ๋งค์นญ์ด ์๋ ๋ฌธ๋งฅ์ ์ดํดํด์ ๊ฒ์ํด
์ฌ๋ฌ ํธ๋์ญ์ ์ ๋ถ์ํด์ ํจํด์ ์ฐพ์๋ด๋ ๊ธฐ๋ฅ์ ์ถ๊ฐํด๋ณด์. ๐
# 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)}
๐ฏ ์ค์ ํ์ฉ ์๋๋ฆฌ์ค
์ด์ ์ฐ๋ฆฌ๊ฐ ๋ง๋ ์ฑ๋ด์ ์ค์ ๋ก ์ด๋ป๊ฒ ํ์ฉํ ์ ์๋์ง ์ดํด๋ณด์. ๐
โ ๋ํ ํฌ์์(๊ณ ๋)์ ์์ง์์ ์ถ์ ํ๊ณ ํฌ์ ์ธ์ฌ์ดํธ๋ฅผ ์ป์ ์ ์์ด.
โ ์ค๋งํธ ์ปจํธ๋ํธ์ ์ฝ๋์ ๊ฑฐ๋ ํจํด์ ๋ถ์ํด์ ์์ฌ์ค๋ฌ์ด ํ๋์ ์ฐพ์๋ผ ์ ์์ด.
โ ์ฌ๋ฌ ํ ํฐ์ ์์ก์ ํ ๋ฒ์ ์กฐํํ๊ณ ์ด ๊ฐ์น๋ฅผ ๊ณ์ฐํ ์ ์์ด.
โ ๋ธ๋ก์ฒด์ธ ์ด๋ณด์๋ค์๊ฒ ๊ฐ๋ ์ ์ฝ๊ฒ ์ค๋ช ํด์ค ์ ์์ด.
์ฑ๋ด ์ฒ๋ฆฌ ๊ณผ์ :
1. ์ฃผ์์ ์ต๊ทผ ํธ๋์ญ์ ์กฐํ
2. ERC-721 ํ ํฐ ์ ์ก ์ด๋ฒคํธ ํํฐ๋ง
3. ๊ฐ NFT ์ปจํธ๋ํธ ์ ๋ณด ์กฐํ
4. ๊ตฌ๋งค ๊ฐ๊ฒฉ๊ณผ ์๊ธฐ ๋ถ์
5. ๊ฒฐ๊ณผ๋ฅผ ์ดํดํ๊ธฐ ์ฝ๊ฒ ์์ฝ
์ฑ๋ด ์๋ต: "ํด๋น ์ฃผ์๋ ์ต๊ทผ 7์ผ๊ฐ 3๊ฐ์ NFT๋ฅผ ๊ตฌ๋งคํ์ต๋๋ค. Bored Ape #1234๋ฅผ 50 ETH์, CryptoPunk #5678์ 80 ETH์ ๊ตฌ๋งคํ์ผ๋ฉฐ, ์ด ํฌ์์ก์ ์ฝ 150 ETH์ ๋๋ค..."
์ด๋ฐ ์์ผ๋ก ๋ณต์กํ ๋ธ๋ก์ฒด์ธ ๋ฐ์ดํฐ๋ฅผ ๋๊ตฌ๋ ์ฝ๊ฒ ์ดํดํ ์ ์๊ฒ ๋ง๋ค์ด์ฃผ๋ ๊ฑฐ์ผ! ๐
โก ์ฑ๋ฅ ์ต์ ํ ํ
์ฑ๋ด์ด ์ ์๋ํ๋ ๊ฑด ์ข์๋ฐ, ๋ ๋น ๋ฅด๊ณ ํจ์จ์ ์ผ๋ก ๋ง๋ค ์ ์์ด. ๋ช ๊ฐ์ง ์ต์ ํ ๋ฐฉ๋ฒ์ ์๋ ค์ค๊ฒ. ๐
๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ฐ๋ณตํด์ ์กฐํํ๋ ๊ฑด ๋นํจ์จ์ ์ด์ผ. ์บ์ฑ์ ๊ตฌํํด๋ณด์:
# 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
์ฌ๋ฌ 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
๋ง์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ ๋๋ ๋ฐฐ์น๋ก ๋๋ ์ ์ฒ๋ฆฌํ๋ ๊ฒ ์ข์:
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 ํค ํ๋์ฝ๋ฉ
โ ๊นํ๋ธ์ .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 ์ฌ์ฉ (ํ๋ก๋์ ํ๊ฒฝ)
- โ๏ธ ์๋ฌ ๋ฉ์์ง์ ๋ฏผ๊ฐํ ์ ๋ณด ํฌํจํ์ง ์๊ธฐ
- โ๏ธ ๋ก๊น ์ ๊ฐ์ธ์ ๋ณด ๋ง์คํน
- โ๏ธ ์ ๊ธฐ์ ์ธ ์์กด์ฑ ์ ๋ฐ์ดํธ
- โ๏ธ ๋ ์ดํธ ๋ฆฌ๋ฏธํ ๊ตฌํ
๐ ๋ฐฐํฌํ๊ธฐ
๋ก์ปฌ์์ ์ ์๋ํ๋ ์ฑ๋ด์ ์ด์ ์ค์ ๋ก ๋ฐฐํฌํด๋ณด์! ์ฌ๋ฌ ์ต์ ์ด ์์ด. โ๏ธ
๊ฐ์ฅ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ 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
๋ค๋ฅธ ์ ํ๋ฆฌ์ผ์ด์ ์์ ์ฌ์ฉํ ์ ์๋ 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
์ด๋์๋ ์ฝ๊ฒ ๋ฐฐํฌํ ์ ์๋๋ก 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
โข Railway: ๊ฐ๋จํ ๋ฐฐํฌ, ๋ฌด๋ฃ ํฐ์ด ์ ๊ณต
โข Render: Docker ์ง์, ์๋ ๋ฐฐํฌ
โข AWS/GCP/Azure: ํ๋ก๋์ ๋ ๋ฒจ ๋ฐฐํฌ
โข Vercel: Next.js์ ํจ๊ป ์ฌ์ฉ ์ ์ข์
๐ ๋๋ฒ๊น ๊ณผ ๋ฌธ์ ํด๊ฒฐ
๊ฐ๋ฐํ๋ค ๋ณด๋ฉด ์ฌ๋ฌ ๋ฌธ์ ์ ๋ถ๋ชํ๊ฒ ๋ผ. ์์ฃผ ๋ฐ์ํ๋ ๋ฌธ์ ๋ค๊ณผ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ ๋ฆฌํด๋ดค์ด. ๐ง
ํด๊ฒฐ:
1. .env ํ์ผ์ INFURA_API_KEY ํ์ธ
2. Infura ๋์๋ณด๋์์ ํ๋ก์ ํธ ์ํ ํ์ธ
3. ๋คํธ์ํฌ ์ด๋ฆ ํ์ธ (mainnet, goerli, sepolia ๋ฑ)
4. ๋ฐฉํ๋ฒฝ ์ค์ ํ์ธ
ํด๊ฒฐ:
1. ์บ์ฑ ๊ตฌํ
2. ์์ฒญ ๊ฐ ๋๋ ์ด ์ถ๊ฐ
3. ์ ๋ฃ ํ๋์ผ๋ก ์ ๊ทธ๋ ์ด๋
4. ์ฌ๋ฌ API ํค ๋กํ ์ด์
ํด๊ฒฐ:
1. ์ฃผ์๊ฐ 0x๋ก ์์ํ๋์ง ํ์ธ
2. 42์๋ฆฌ 16์ง์์ธ์ง ํ์ธ
3. Web3.to_checksum_address() ์ฌ์ฉ
4. ์ ๋ ฅ ๊ฒ์ฆ ๋ก์ง ์ถ๊ฐ
ํด๊ฒฐ:
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 ๋ฉํ๋ฐ์ดํฐ ์กฐํ
โข ๊ฐ๊ฒฉ ์ถ์ด ๋ถ์
โข ํฌ๊ท๋ ๊ณ์ฐ
โข ์ปฌ๋ ์ ํต๊ณ
โข ์ ๋์ฑ ํ ์ ๋ณด
โข ์คํ ์ดํน ์์ต๋ฅ
โข ๋์ถ/์ฐจ์ ์ ๋ณด
โข ๊ฐ์ค๋น ์ต์ ํ ์ ์
โข ๊ฑฐ๋ ํจํด ๋ถ์
โข ๋คํธ์ํฌ ๊ทธ๋ํ
โข ์ด์ ๊ฑฐ๋ ํ์ง
โข ์์ธก ๋ชจ๋ธ๋ง
โข BSC ์ง์
โข Solana ํตํฉ
โข ํฌ๋ก์ค์ฒด์ธ ์ถ์
โข ์ฒด์ธ๋ณ ๋น๊ต
2. ์ค๋งํธ ์๋ฆผ ์์คํ : ํน์ ์กฐ๊ฑด์ด ๋ง์กฑ๋๋ฉด ์๋ฆผ (์: ๊ณ ๋ ์ง๊ฐ ์์ง์, ๊ฐ๊ฒฉ ๋ณ๋)
3. ์ธ๊ธ ๊ณ์ฐ๊ธฐ: ๊ฑฐ๋ ๋ด์ญ์ ๋ถ์ํด์ ์ธ๊ธ ๋ณด๊ณ ์ ์๋ ์์ฑ
4. ๊ต์ก ํ๋ซํผ: ๋ธ๋ก์ฒด์ธ ์ด๋ณด์๋ฅผ ์ํ ๋ํํ ํ์ต ๋๊ตฌ
5. ๊ฐ์ฌ ๋๊ตฌ: ์ค๋งํธ ์ปจํธ๋ํธ ๋ณด์ ๋ถ์ ๋ฐ ์ทจ์ฝ์ ํ์ง
์ด๋ฐ ๊ธฐ๋ฅ๋ค์ ์ถ๊ฐํ๋ฉด ๋จ์ํ ์ฑ๋ด์ ๋์ด์ ์ค์ ๋ก ์ ์ฉํ ๋ธ๋ก์ฒด์ธ ๋ถ์ ํ๋ซํผ์ผ๋ก ๋ฐ์ ์ํฌ ์ ์์ด! ๐
ํน์ ์ด๋ฐ ๊ณ ๊ธ ๊ธฐ๋ฅ ๊ตฌํ์ ๋์์ด ํ์ํ๋ค๋ฉด, ์ฌ๋ฅ๋ท์์ ๋ธ๋ก์ฒด์ธ๊ณผ AI ์ ๋ฌธ๊ฐ๋ค์ ์ฐพ์๋ณผ ์ ์์ด. ์ค๋ฌด ๊ฒฝํ์ด ํ๋ถํ ๊ฐ๋ฐ์๋ค์ ๋ฉํ ๋ง์ด๋ ์ฝ๋ ๋ฆฌ๋ทฐ๋ฅผ ๋ฐ์ผ๋ฉด ํ๋ก์ ํธ ํ๋ฆฌํฐ๋ฅผ ํ ๋จ๊ณ ๋์ผ ์ ์๊ฑฐ๋ !
๐ฐ ์์ตํ ์ ๋ต
์ข์ ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์๋ค๋ฉด ์์ตํ๋ ๊ณ ๋ คํด๋ณผ ์ ์์ด. ๋ช ๊ฐ์ง ๋ฐฉ๋ฒ์ ์๊ฐํ ๊ฒ. ๐ธ
โข ๊ธฐ๋ณธ ์์ก ์กฐํ
โข ์ผ์ผ 10ํ ์ง๋ฌธ ์ ํ
โข ์ต๊ทผ 10๊ฐ ํธ๋์ญ์ ๋ง ์กฐํ
ํ๋ฆฌ๋ฏธ์ ํฐ์ด ($9.99/์):
โข ๋ฌด์ ํ ์ง๋ฌธ
โข ๊ณ ๊ธ ๋ถ์ ๊ธฐ๋ฅ
โข ์ค์๊ฐ ์๋ฆผ
โข API ์ก์ธ์ค
โข ์ฐ์ ์ง์
์ํฐํ๋ผ์ด์ฆ ํฐ์ด (๋ง์ถค ๊ฐ๊ฒฉ):
โข ์ ์ฉ ์ธ์คํด์ค
โข ์ปค์คํ ๊ธฐ๋ฅ
โข SLA ๋ณด์ฅ
โข ์ ๋ด ์ง์ํ
โข ์์ฒญ๋น ๊ณผ๊ธ ($0.01/request)
โข ์๊ฐ ๊ตฌ๋ ($49/์ - 10,000 requests)
โข ํ์ดํธ๋ผ๋ฒจ ์๋ฃจ์ ์ ๊ณต
โข 1:1 ๋ฉํ ๋ง
โข ๊ธฐ์ ๊ต์ก ํ๋ก๊ทธ๋จ
โข ์ ์์ฑ ์ถํ
๐ ํ์ต ๋ฆฌ์์ค
๋ ๊น์ด ๊ณต๋ถํ๊ณ ์ถ๋ค๋ฉด ์ด๋ฐ ๋ฆฌ์์ค๋ค์ ์ถ์ฒํด. ๐
โข Web3.py: web3py.readthedocs.io
โข OpenAI: platform.openai.com/docs
โข Ethereum: ethereum.org/developers
โข Coursera: "Blockchain Specialization"
โข YouTube: Patrick Collins, Dapp University
โข freeCodeCamp: Solidity ํํ ๋ฆฌ์ผ
โข Discord: LangChain, Ethereum
โข Stack Overflow: ethereum, web3
โข GitHub: ์คํ์์ค ํ๋ก์ ํธ ์ฐธ์ฌ
โข Towards Data Science (AI/ML)
โข Medium: LangChain, Web3 ํ๊ทธ
โข Dev.to: ๊ฐ๋ฐ์ ๋ธ๋ก๊ทธ
๐ฏ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์, ์ฌ๊ธฐ๊น์ง ์ ๋ง ๊ธด ์ฌ์ ์ด์์ด! ๐
์ฐ๋ฆฌ๋ ํ์ด์ฌ๊ณผ ๋ญ์ฒด์ธ์ ์ฌ์ฉํด์ ๋ธ๋ก์ฒด์ธ ๋ฐ์ดํฐ๋ฅผ ํด์ํ๋ AI ์ฑ๋ด์ ์ฒ์๋ถํฐ ๋๊น์ง ๋ง๋ค์ด๋ดค์ด. ๋ธ๋ก์ฒด์ธ ์ฐ๊ฒฐ๋ถํฐ LangChain ์์ด์ ํธ ๊ตฌ์ถ, ์ฌ์ฉ์ ์ธํฐํ์ด์ค, ๋ณด์, ๋ฐฐํฌ๊น์ง ์ ๊ณผ์ ์ ๋ค๋ค์ง.
- โ Web3.py๋ก ๋ธ๋ก์ฒด์ธ ๋ฐ์ดํฐ ์กฐํํ๊ธฐ
- โ LangChain์ผ๋ก AI ์์ด์ ํธ ๋ง๋ค๊ธฐ
- โ ๋๊ตฌ(Tools)๋ฅผ ์ ์ํ๊ณ AI๊ฐ ์ ํํ๊ฒ ํ๊ธฐ
- โ ๋ํ ๋ฉ๋ชจ๋ฆฌ์ ์ปจํ ์คํธ ๊ด๋ฆฌ
- โ ๋ฒกํฐ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ก ์ง์ ์ ์ฅํ๊ธฐ
- โ ์ฑ๋ฅ ์ต์ ํ์ ์บ์ฑ ์ ๋ต
- โ ๋ณด์ ๊ณ ๋ ค์ฌํญ
- โ ์ค์ ๋ฐฐํฌ ๋ฐฉ๋ฒ
์ด์ ๋น์ ์ ๋ธ๋ก์ฒด์ธ๊ณผ AI๋ฅผ ๊ฒฐํฉํ ์ค์ฉ์ ์ธ ์ ํ๋ฆฌ์ผ์ด์
์ ๋ง๋ค ์ ์๋ ๋ฅ๋ ฅ์ ๊ฐ์ท์ด! ๐ช
ํ์ง๋ง ์ด๊ฑด ์์์ผ ๋ฟ์ด์ผ. ์ฌ๊ธฐ์ ๋ฐฐ์ด ๊ธฐ์ ๋ค์ ๋ฐํ์ผ๋ก ๋ ์ฐฝ์์ ์ด๊ณ ํ์ ์ ์ธ ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์ด๋ณผ ์ ์์ด. NFT ๋ถ์ ๋๊ตฌ, DeFi ๋์๋ณด๋, ์ค๋งํธ ์ปจํธ๋ํธ ๊ฐ์ฌ ๋๊ตฌ... ๊ฐ๋ฅ์ฑ์ ๋ฌด๊ถ๋ฌด์งํด!
2. ์์ ๋ง์ ๊ธฐ๋ฅ ์ถ๊ฐํด๋ณด๊ธฐ
3. ์ค์ ํ๋ก์ ํธ์ ์ ์ฉํด๋ณด๊ธฐ
4. ์ปค๋ฎค๋ํฐ์ ๊ณต์ ํ๊ณ ํผ๋๋ฐฑ ๋ฐ๊ธฐ
5. ์คํ์์ค๋ก ๊ณต๊ฐํ๊ฑฐ๋ ์์ฉํ ๊ณ ๋ คํ๊ธฐ
๋ธ๋ก์ฒด์ธ๊ณผ AI๋ ์์ผ๋ก ๋์ฑ ์ค์ํด์ง ๊ธฐ์ ์ด์ผ. ์ง๊ธ ๋ฐฐ์ด ๊ฒ๋ค์ด ๋ฏธ๋์ ์ปค๋ฆฌ์ด์ ํฐ ๋์์ด ๋ ๊ฑฐ๋ผ๊ณ ํ์ ํด. ๐
ํน์ ํ๋ก์ ํธ๋ฅผ ์งํํ๋ค๊ฐ ๋งํ๋ ๋ถ๋ถ์ด ์๊ฑฐ๋, ๋ ์ ๋ฌธ์ ์ธ ์กฐ์ธ์ด ํ์ํ๋ค๋ฉด ์ฃผ์ ํ์ง ๋ง๊ณ ๋์์ ๊ตฌํด. ๊ฐ๋ฐ์ ์ปค๋ฎค๋ํฐ๋ ํญ์ ์ด๋ ค์๊ณ , ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์๋ ์ค๋ฌด ์ ๋ฌธ๊ฐ๋ค์ ๋ฉํ ๋ง๋ ๋ฐ์ ์ ์์ด.
์, ์ด์ ๋น์ ์ฐจ๋ก์ผ! ์ค๋ ๋ฐฐ์ด ๊ฒ๋ค์ ๋ฐํ์ผ๋ก ๋ฉ์ง ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์ด๋ด. ๊ทธ๋ฆฌ๊ณ ์ธ์ ๊ฐ ๋น์ ์ด ๋ง๋ ๋ธ๋ก์ฒด์ธ AI ์ฑ๋ด์ด ๋ง์ ์ฌ๋๋ค์๊ฒ ๋์์ ์ฃผ๋ ๋ ์ด ์ค๊ธฐ๋ฅผ ๊ธฐ๋ํ ๊ฒ! โจ
Happy Coding! ๐๐๐ป
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.