🎪 왜 로컬에서 LLM을 돌려야 할까?

🦙 Ollama가 뭐길래?

🌟 Ollama의 핵심 특징

⚙️ Ollama 설치하기

🍎 macOS 설치

🐧 Linux 설치

curl -fsSL https://ollama.ai/install.sh | sh

🪟 Windows 설치

✅ 설치 확인

ollama --version

🚀 첫 번째 모델 실행하기

🎯 Llama 2 실행하기

ollama run llama2

>>> 안녕? 너는 누구야?

안녕하세요! 저는 Llama 2라고 하는 AI 어시스턴트입니다. 
Meta에서 개발한 대형 언어 모델이에요. 질문에 답하고, 
정보를 제공하고, 대화를 나누는 것을 도와드릴 수 있습니다. 
무엇을 도와드릴까요?

🔄 다른 모델들 시도해보기

🎮 대화 모드 사용하기

>>> /set temperature 0.9

🛠️ API로 Ollama 사용하기

🌐 기본 API 구조

🐍 Python으로 사용하기

pip install ollama

import ollama

response = ollama.chat(model='llama2', messages=[
  {
    'role': 'user',
    'content': 'Python으로 피보나치 수열을 구현하는 방법을 알려줘',
  },
])

print(response['message']['content'])

import ollama

stream = ollama.chat(
    model='llama2',
    messages=[{'role': 'user', 'content': '긴 이야기를 들려줘'}],
    stream=True,
)

for chunk in stream:
  print(chunk['message']['content'], end='', flush=True)

🟨 JavaScript/Node.js로 사용하기

npm install ollama

import ollama from 'ollama'

const response = await ollama.chat({
  model: 'llama2',
  messages: [{ role: 'user', content: 'JavaScript는 왜 인기가 많을까?' }],
})

console.log(response.message.content)

const response = await ollama.chat({
  model: 'llama2',
  messages: [{ role: 'user', content: '긴 이야기를 들려줘' }],
  stream: true,
})

for await (const part of response) {
  process.stdout.write(part.message.content)
}

🔗 REST API 직접 호출하기

curl http://localhost:11434/api/generate -d '{
  "model": "llama2",
  "prompt": "하늘은 왜 파란색일까?",
  "stream": false
}'

{
  "model": "llama2",
  "created_at": "2024-01-15T09:30:00.123456Z",
  "response": "하늘이 파란색으로 보이는 이유는...",
  "done": true
}

🎨 Modelfile로 커스텀 모델 만들기

📝 Modelfile 기본 구조

FROM llama2

PARAMETER temperature 0.8
PARAMETER top_p 0.9

SYSTEM """
당신은 친절한 한국어 AI 어시스턴트입니다. 
항상 존댓말을 사용하고, 상세하고 정확한 답변을 제공합니다.
"""

TEMPLATE """{{ .System }}

사용자: {{ .Prompt }}

어시스턴트: """

🚀 실전 예제: 코딩 어시스턴트 만들기

# Modelfile
FROM codellama:7b

PARAMETER temperature 0.3
PARAMETER top_p 0.9
PARAMETER num_ctx 4096

SYSTEM """
당신은 전문 프로그래밍 어시스턴트입니다.

역할:
- 코드 작성, 리뷰, 디버깅 지원
- 알고리즘과 자료구조 설명
- 베스트 프랙티스 제안
- 성능 최적화 조언

답변 규칙:
1. 코드는 반드시 주석과 함께 제공
2. 여러 해결 방법이 있다면 장단점 비교
3. 실행 가능한 완전한 예제 제공
4. 보안과 성능을 항상 고려
"""

TEMPLATE """{{ .System }}

## 질문
{{ .Prompt }}

## 답변
"""

ollama create my-coding-assistant -f Modelfile.coding

ollama run my-coding-assistant

💼 실전 예제: 비즈니스 분석가

FROM mistral

PARAMETER temperature 0.5
PARAMETER top_p 0.95

SYSTEM """
당신은 데이터 기반 비즈니스 분석 전문가입니다.

전문 분야:
- 데이터 분석 및 시각화
- 비즈니스 인사이트 도출
- KPI 설정 및 모니터링
- 의사결정 지원

답변 스타일:
- 데이터 기반 객관적 분석
- 명확한 수치와 근거 제시
- 실행 가능한 액션 아이템 제안
- 비즈니스 용어 사용
"""

🎭 실전 예제: 창의적 작가

FROM llama2

PARAMETER temperature 1.2
PARAMETER top_p 0.95
PARAMETER repeat_penalty 1.2

SYSTEM """
당신은 창의적인 작가이자 스토리텔러입니다.

특기:
- 흥미진진한 이야기 창작
- 생생한 묘사와 감정 표현
- 독창적인 아이디어 제안
- 다양한 장르 글쓰기

글쓰기 원칙:
- 독자의 감정을 움직이는 서사
- 구체적이고 감각적인 묘사
- 예상을 뒤엎는 전개
- 캐릭터의 깊이 있는 심리 묘사
"""

🔧 고급 기능: 어댑터 사용하기

FROM llama2

ADAPTER ./my-lora-adapter.bin

PARAMETER temperature 0.7

⚡ 성능 최적화 팁

💾 하드웨어 최적화

⚙️ 설정 최적화

ollama run llama2 --num-ctx 4096

ollama run llama2 ""

🔄 모델 선택 전략

🔗 실전 프로젝트 예제

📚 프로젝트 1: 문서 요약 봇

import ollama
import sys

def summarize_document(file_path, model='llama2'):
    # 파일 읽기
    with open(file_path, 'r', encoding='utf-8') as f:
        content = f.read()
    
    # 너무 길면 청크로 나누기
    max_chunk_size = 3000
    chunks = [content[i:i+max_chunk_size] 
              for i in range(0, len(content), max_chunk_size)]
    
    summaries = []
    
    for i, chunk in enumerate(chunks):
        print(f"청크 {i+1}/{len(chunks)} 처리 중...")
        
        response = ollama.chat(model=model, messages=[
            {
                'role': 'system',
                'content': '당신은 문서 요약 전문가입니다. 핵심 내용을 간결하게 요약하세요.'
            },
            {
                'role': 'user',
                'content': f'다음 텍스트를 3-5문장으로 요약해주세요:\n\n{chunk}'
            }
        ])
        
        summaries.append(response['message']['content'])
    
    # 최종 요약
    if len(summaries) > 1:
        combined = '\n\n'.join(summaries)
        final_response = ollama.chat(model=model, messages=[
            {
                'role': 'user',
                'content': f'다음 요약들을 하나로 통합해주세요:\n\n{combined}'
            }
        ])
        return final_response['message']['content']
    else:
        return summaries[0]

if __name__ == '__main__':
    if len(sys.argv) < 2:
        print("사용법: python summarizer.py <파일경로>")
        sys.exit(1)
    
    summary = summarize_document(sys.argv[1])
    print("\n=== 요약 결과 ===")
    print(summary)

💬 프로젝트 2: 로컬 챗봇 웹 인터페이스

# app.py
from flask import Flask, render_template, request, jsonify, Response
import ollama
import json

app = Flask(__name__)

# 대화 히스토리 저장
conversations = {}

@app.route('/')
def home():
    return render_template('chat.html')

@app.route('/chat', methods=['POST'])
def chat():
    data = request.json
    user_message = data.get('message')
    session_id = data.get('session_id', 'default')
    
    # 세션별 대화 히스토리 관리
    if session_id not in conversations:
        conversations[session_id] = []
    
    conversations[session_id].append({
        'role': 'user',
        'content': user_message
    })
    
    def generate():
        full_response = ""
        stream = ollama.chat(
            model='llama2',
            messages=conversations[session_id],
            stream=True
        )
        
        for chunk in stream:
            content = chunk['message']['content']
            full_response += content
            yield f"data: {json.dumps({'content': content})}\n\n"
        
        # 응답을 히스토리에 추가
        conversations[session_id].append({
            'role': 'assistant',
            'content': full_response
        })
    
    return Response(generate(), mimetype='text/event-stream')

if __name__ == '__main__':
    app.run(debug=True, port=5000)

<!DOCTYPE html>
<html>
<head>
    <title>로컬 AI 챗봇</title>
    <style>
        body { font-family: Arial; max-width: 800px; margin: 50px auto; }
        #chat-box { height: 400px; border: 1px solid #ccc; 
                    overflow-y: scroll; padding: 10px; }
        .message { margin: 10px 0; padding: 10px; border-radius: 5px; }
        .user { background: #e3f2fd; text-align: right; }
        .assistant { background: #f5f5f5; }
        #input-box { display: flex; margin-top: 10px; }
        #message-input { flex: 1; padding: 10px; }
        #send-btn { padding: 10px 20px; }
    </style>
</head>
<body>
    <h1>🤖 로컬 AI 챗봇</h1>
    <div id="chat-box"></div>
    <div id="input-box">
        <input type="text" id="message-input" 
               placeholder="메시지를 입력하세요...">
        <button id="send-btn">전송</button>
    </div>
    
    <script>
        const chatBox = document.getElementById('chat-box');
        const messageInput = document.getElementById('message-input');
        const sendBtn = document.getElementById('send-btn');
        
        function addMessage(content, role) {
            const div = document.createElement('div');
            div.className = `message ${role}`;
            div.textContent = content;
            chatBox.appendChild(div);
            chatBox.scrollTop = chatBox.scrollHeight;
            return div;
        }
        
        async function sendMessage() {
            const message = messageInput.value.trim();
            if (!message) return;
            
            addMessage(message, 'user');
            messageInput.value = '';
            
            const assistantDiv = addMessage('', 'assistant');
            
            const response = await fetch('/chat', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ 
                    message: message,
                    session_id: 'user123'
                })
            });
            
            const reader = response.body.getReader();
            const decoder = new TextDecoder();
            
            while (true) {
                const {value, done} = await reader.read();
                if (done) break;
                
                const text = decoder.decode(value);
                const lines = text.split('\n');
                
                for (const line of lines) {
                    if (line.startsWith('data: ')) {
                        const data = JSON.parse(line.slice(6));
                        assistantDiv.textContent += data.content;
                        chatBox.scrollTop = chatBox.scrollHeight;
                    }
                }
            }
        }
        
        sendBtn.addEventListener('click', sendMessage);
        messageInput.addEventListener('keypress', (e) => {
            if (e.key === 'Enter') sendMessage();
        });
    </script>
</body>
</html>

🔍 프로젝트 3: 코드 리뷰 도구

import ollama
import os
import sys

def review_code(file_path):
    with open(file_path, 'r', encoding='utf-8') as f:
        code = f.read()
    
    file_ext = os.path.splitext(file_path)[1]
    language_map = {
        '.py': 'Python',
        '.js': 'JavaScript',
        '.java': 'Java',
        '.cpp': 'C++',
        '.go': 'Go'
    }
    language = language_map.get(file_ext, '알 수 없음')
    
    prompt = f"""
다음 {language} 코드를 리뷰해주세요:

```{language.lower()}
{code}
```

다음 관점에서 분석해주세요:
1. 코드 품질 및 가독성
2. 잠재적 버그나 문제점
3. 성능 최적화 가능성
4. 보안 이슈
5. 개선 제안

각 항목별로 구체적인 예시와 함께 설명해주세요.
"""
    
    print("코드 리뷰 중... ⏳")
    
    response = ollama.chat(
        model='codellama',
        messages=[
            {
                'role': 'system',
                'content': '당신은 시니어 소프트웨어 엔지니어입니다. 코드를 꼼꼼히 리뷰하고 건설적인 피드백을 제공합니다.'
            },
            {
                'role': 'user',
                'content': prompt
            }
        ]
    )
    
    return response['message']['content']

if __name__ == '__main__':
    if len(sys.argv) < 2:
        print("사용법: python code_reviewer.py <파일경로>")
        sys.exit(1)
    
    review = review_code(sys.argv[1])
    print("\n" + "="*50)
    print("코드 리뷰 결과")
    print("="*50 + "\n")
    print(review)

🌐 Ollama와 다른 도구 통합하기

🦜 LangChain과 통합

pip install langchain langchain-community

from langchain_community.llms import Ollama
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

# Ollama LLM 초기화
llm = Ollama(model="llama2")

# 프롬프트 템플릿
template = """
질문: {question}

다음 형식으로 답변해주세요:
1. 간단한 답변
2. 상세한 설명
3. 관련 예시
"""

prompt = PromptTemplate(template=template, input_variables=["question"])

# 체인 생성
chain = LLMChain(llm=llm, prompt=prompt)

# 실행
result = chain.run(question="머신러닝과 딥러닝의 차이는?")
print(result)

from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain_community.document_loaders import TextLoader

# 문서 로드
loader = TextLoader("knowledge_base.txt")
documents = loader.load()

# 텍스트 분할
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
texts = text_splitter.split_documents(documents)

# 임베딩 생성 및 벡터 스토어
embeddings = OllamaEmbeddings(model="llama2")
vectorstore = Chroma.from_documents(
    documents=texts,
    embedding=embeddings
)

# RAG 체인
qa_chain = RetrievalQA.from_chain_type(
    llm=Ollama(model="llama2"),
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

# 질문
answer = qa_chain.run("문서에서 중요한 내용은?")
print(answer)

🤗 Hugging Face Transformers와 통합

import ollama
from typing import List, Dict

class OllamaWrapper:
    def __init__(self, model_name: str):
        self.model_name = model_name
    
    def generate(self, prompt: str, max_length: int = 512) -> str:
        response = ollama.generate(
            model=self.model_name,
            prompt=prompt
        )
        return response['response']
    
    def chat(self, messages: List[Dict[str, str]]) -> str:
        response = ollama.chat(
            model=self.model_name,
            messages=messages
        )
        return response['message']['content']

# 사용
model = OllamaWrapper("llama2")
result = model.generate("인공지능의 미래는?")
print(result)

🎨 Gradio로 UI 만들기

pip install gradio

import gradio as gr
import ollama

def chat_with_ollama(message, history):
    # 히스토리를 Ollama 형식으로 변환
    messages = []
    for human, assistant in history:
        messages.append({'role': 'user', 'content': human})
        messages.append({'role': 'assistant', 'content': assistant})
    messages.append({'role': 'user', 'content': message})
    
    # 스트리밍 응답
    response = ""
    stream = ollama.chat(
        model='llama2',
        messages=messages,
        stream=True
    )
    
    for chunk in stream:
        response += chunk['message']['content']
        yield response

# Gradio 인터페이스
demo = gr.ChatInterface(
    chat_with_ollama,
    title="🦙 Ollama 챗봇",
    description="로컬에서 실행되는 AI 챗봇입니다.",
    theme="soft",
    examples=[
        "Python으로 웹 크롤러 만드는 법 알려줘",
        "머신러닝 공부 로드맵 추천해줘",
        "재미있는 농담 하나 해줘"
    ]
)

demo.launch(share=True)

📊 Streamlit으로 대시보드 만들기

pip install streamlit

import streamlit as st
import ollama
import pandas as pd

st.title("📊 AI 데이터 분석 어시스턴트")

# 사이드바
with st.sidebar:
    st.header("설정")
    model = st.selectbox("모델 선택", ["llama2", "mistral", "codellama"])
    temperature = st.slider("Temperature", 0.0, 2.0, 0.7)

# 파일 업로드
uploaded_file = st.file_uploader("CSV 파일 업로드", type=['csv'])

if uploaded_file:
    df = pd.read_csv(uploaded_file)
    st.dataframe(df.head())
    
    # 데이터 요약
    summary = df.describe().to_string()
    
    # AI에게 분석 요청
    if st.button("AI 분석 시작"):
        with st.spinner("분석 중..."):
            prompt = f"""
다음 데이터셋을 분석해주세요:

컬럼: {', '.join(df.columns)}
행 수: {len(df)}

통계 요약:
{summary}

다음 내용을 포함해서 분석해주세요:
1. 데이터의 주요 특징
2. 흥미로운 패턴이나 이상치
3. 추가 분석 제안
"""
            
            response = ollama.chat(
                model=model,
                messages=[{'role': 'user', 'content': prompt}]
            )
            
            st.success("분석 완료!")
            st.markdown(response['message']['content'])

# 자유 질문
st.header("💬 데이터에 대해 질문하기")
question = st.text_input("질문을 입력하세요")

if question and uploaded_file:
    with st.spinner("답변 생성 중..."):
        context = f"데이터셋 정보: {df.head(10).to_string()}"
        prompt = f"{context}\n\n질문: {question}"
        
        response = ollama.chat(
            model=model,
            messages=[{'role': 'user', 'content': prompt}]
        )
        
        st.write(response['message']['content'])

🔒 보안과 프라이버시

🔐 데이터 보안

⚠️ 주의사항

import signal

class TimeoutError(Exception):
    pass

def timeout_handler(signum, frame):
    raise TimeoutError()

signal.signal(signal.SIGALRM, timeout_handler)
signal.alarm(30)  # 30초 타임아웃

try:
    response = ollama.chat(...)
finally:
    signal.alarm(0)  # 타이머 해제

🏢 기업 환경에서의 고려사항

🐛 문제 해결 가이드

❌ 일반적인 문제들

🔍 디버깅 팁

🆘 커뮤니티 지원

🚀 고급 활용 사례

🔄 멀티 모델 앙상블

import ollama
from collections import Counter

def ensemble_chat(prompt, models=['llama2', 'mistral', 'phi']):
    """여러 모델의 답변을 수집하고 종합"""
    responses = []
    
    for model in models:
        try:
            response = ollama.chat(
                model=model,
                messages=[{'role': 'user', 'content': prompt}]
            )
            responses.append(response['message']['content'])
        except Exception as e:
            print(f"{model} 에러: {e}")
    
    # 최종 답변 생성 (메타 모델 사용)
    combined_prompt = f"""
다음은 같은 질문에 대한 여러 AI의 답변들입니다:

질문: {prompt}

답변 1:
{responses[0]}

답변 2:
{responses[1]}

답변 3:
{responses[2]}

이 답변들을 종합해서 가장 정확하고 완전한 답변을 만들어주세요.
"""
    
    final = ollama.chat(
        model='llama2',
        messages=[{'role': 'user', 'content': combined_prompt}]
    )
    
    return final['message']['content']

# 사용
result = ensemble_chat("양자 컴퓨팅의 원리를 설명해줘")
print(result)

🎯 체인 오브 쏘트(Chain of Thought)

def chain_of_thought(problem, model='llama2'):
    """단계별 사고 과정을 거쳐 문제 해결"""
    
    # 1단계: 문제 분석
    analysis_prompt = f"""
다음 문제를 분석해주세요:
{problem}

다음 형식으로 답변해주세요:
1. 문제의 핵심
2. 필요한 정보
3. 해결 단계
"""
    
    analysis = ollama.chat(
        model=model,
        messages=[{'role': 'user', 'content': analysis_prompt}]
    )
    
    print("=== 문제 분석 ===")
    print(analysis['message']['content'])
    print()
    
    # 2단계: 단계별 해결
    solution_prompt = f"""
문제: {problem}

분석 결과:
{analysis['message']['content']}

이제 각 단계를 하나씩 실행하면서 최종 답을 도출해주세요.
각 단계의 결과를 명확히 보여주세요.
"""
    
    solution = ollama.chat(
        model=model,
        messages=[{'role': 'user', 'content': solution_prompt}]
    )
    
    print("=== 단계별 해결 ===")
    print(solution['message']['content'])
    print()
    
    # 3단계: 검증
    verification_prompt = f"""
문제: {problem}
해결 과정: {solution['message']['content']}

이 해결 과정이 올바른지 검증하고, 개선점이 있다면 제시해주세요.
"""
    
    verification = ollama.chat(
        model=model,
        messages=[{'role': 'user', 'content': verification_prompt}]
    )
    
    print("=== 검증 ===")
    print(verification['message']['content'])
    
    return {
        'analysis': analysis['message']['content'],
        'solution': solution['message']['content'],
        'verification': verification['message']['content']
    }

# 사용
result = chain_of_thought(
    "한 농부가 늑대, 염소, 양배추를 데리고 강을 건너야 합니다. "
    "배는 농부와 하나만 태울 수 있습니다. "
    "늑대는 염소를, 염소는 양배추를 먹습니다. "
    "어떻게 모두 안전하게 건널 수 있을까요?"
)

🔁 자기 개선 루프

def self_improving_chat(prompt, iterations=3, model='llama2'):
    """반복적으로 답변을 개선"""
    
    current_response = ""
    
    for i in range(iterations):
        print(f"\n=== 반복 {i+1}/{iterations} ===")
        
        if i == 0:
            # 첫 번째 답변
            messages = [{'role': 'user', 'content': prompt}]
        else:
            # 이전 답변 개선
            messages = [
                {'role': 'user', 'content': prompt},
                {'role': 'assistant', 'content': current_response},
                {'role': 'user', 'content': 
                 '이 답변을 다음 관점에서 개선해주세요:\n'
                 '1. 더 정확한 정보\n'
                 '2. 더 명확한 설명\n'
                 '3. 실용적인 예시 추가'}
            ]
        
        response = ollama.chat(model=model, messages=messages)
        current_response = response['message']['content']
        print(current_response)
    
    return current_response

# 사용
final_answer = self_improving_chat(
    "머신러닝 모델의 과적합을 방지하는 방법을 알려줘",
    iterations=3
)

📊 배치 처리 시스템

import asyncio
import ollama
from concurrent.futures import ThreadPoolExecutor
import queue
import threading

class BatchProcessor:
    def __init__(self, model='llama2', max_workers=4):
        self.model = model
        self.max_workers = max_workers
        self.task_queue = queue.Queue()
        self.results = {}
        
    def process_item(self, item_id, prompt):
        """단일 아이템 처리"""
        try:
            response = ollama.chat(
                model=self.model,
                messages=[{'role': 'user', 'content': prompt}]
            )
            return item_id, response['message']['content']
        except Exception as e:
            return item_id, f"Error: {str(e)}"
    
    def worker(self):
        """워커 스레드"""
        while True:
            try:
                item = self.task_queue.get(timeout=1)
                if item is None:
                    break
                
                item_id, prompt = item
                result = self.process_item(item_id, prompt)
                self.results[result[0]] = result[1]
                
                self.task_queue.task_done()
            except queue.Empty:
                continue
    
    def process_batch(self, items):
        """배치 처리"""
        # 작업 큐에 추가
        for item_id, prompt in items:
            self.task_queue.put((item_id, prompt))
        
        # 워커 스레드 시작
        threads = []
        for _ in range(self.max_workers):
            t = threading.Thread(target=self.worker)
            t.start()
            threads.append(t)
        
        # 모든 작업 완료 대기
        self.task_queue.join()
        
        # 워커 종료
        for _ in range(self.max_workers):
            self.task_queue.put(None)
        
        for t in threads:
            t.join()
        
        return self.results

# 사용 예제
processor = BatchProcessor(model='llama2', max_workers=4)

# 처리할 데이터
items = [
    (1, "Python의 장점을 3가지만 말해줘"),
    (2, "JavaScript의 특징을 설명해줘"),
    (3, "Go 언어는 어떤 용도로 사용돼?"),
    (4, "Rust가 주목받는 이유는?"),
    (5, "TypeScript를 사용하는 이유는?"),
]

print("배치 처리 시작...")
results = processor.process_batch(items)

for item_id, result in sorted(results.items()):
    print(f"\n=== 항목 {item_id} ===")
    print(result)

🎨 프롬프트 템플릿 시스템

class PromptTemplate:
    def __init__(self, template, model='llama2'):
        self.template = template
        self.model = model
    
    def format(self, **kwargs):
        """템플릿에 변수 채우기"""
        return self.template.format(**kwargs)
    
    def execute(self, **kwargs):
        """템플릿 실행"""
        prompt = self.format(**kwargs)
        response = ollama.chat(
            model=self.model,
            messages=[{'role': 'user', 'content': prompt}]
        )
        return response['message']['content']

# 템플릿 정의
templates = {
    'code_review': PromptTemplate("""
다음 {language} 코드를 리뷰해주세요:

```{language}
{code}
```

다음 관점에서 분석해주세요:
- 코드 품질
- 잠재적 버그
- 성능 최적화
- 보안 이슈
"""),
    
    'explain_concept': PromptTemplate("""
{concept}에 대해 {level} 수준으로 설명해주세요.

포함할 내용:
1. 기본 개념
2. 실제 예시
3. 장단점
4. 사용 사례
"""),
    
    'translate_improve': PromptTemplate("""
다음 텍스트를 {target_language}로 번역하고 개선해주세요:

원문:
{text}

요구사항:
- 자연스러운 표현
- 문화적 맥락 고려
- 전문 용어 정확성
""")
}

# 사용
result = templates['explain_concept'].execute(
    concept="Docker 컨테이너",
    level="초보자"
)
print(result)

🌟 실전 팁과 베스트 프랙티스

💡 프롬프트 엔지니어링 팁

예시 1:
입력: "안녕"
출력: "안녕하세요! 무엇을 도와드릴까요?"

예시 2:
입력: "날씨"
출력: "죄송하지만 실시간 날씨 정보는 제공할 수 없습니다."

이제 다음 입력에 답변해주세요:
입력: "시간"

⚡ 성능 최적화 실전 팁

import hashlib
import json

cache = {}

def cached_chat(prompt, model='llama2'):
    # 캐시 키 생성
    cache_key = hashlib.md5(
        f"{model}:{prompt}".encode()
    ).hexdigest()
    
    if cache_key in cache:
        print("캐시에서 가져옴!")
        return cache[cache_key]
    
    response = ollama.chat(
        model=model,
        messages=[{'role': 'user', 'content': prompt}]
    )
    
    result = response['message']['content']
    cache[cache_key] = result
    return result

# 서버 시작 시
ollama.chat(model='llama2', messages=[
    {'role': 'user', 'content': 'hi'}
])

🛡️ 프로덕션 체크리스트

📈 모니터링과 메트릭

import time
import psutil
import ollama

class OllamaMonitor:
    def __init__(self):
        self.metrics = {
            'total_requests': 0,
            'total_tokens': 0,
            'total_time': 0,
            'errors': 0
        }
    
    def monitored_chat(self, model, messages):
        start_time = time.time()
        
        try:
            response = ollama.chat(model=model, messages=messages)
            
            # 메트릭 업데이트
            self.metrics['total_requests'] += 1
            self.metrics['total_time'] += time.time() - start_time
            
            # 토큰 수 추정 (실제로는 response에서 가져와야 함)
            tokens = len(response['message']['content'].split())
            self.metrics['total_tokens'] += tokens
            
            return response
            
        except Exception as e:
            self.metrics['errors'] += 1
            raise e
    
    def get_stats(self):
        avg_time = (self.metrics['total_time'] / 
                   self.metrics['total_requests'] 
                   if self.metrics['total_requests'] > 0 else 0)
        
        return {
            'total_requests': self.metrics['total_requests'],
            'total_tokens': self.metrics['total_tokens'],
            'average_response_time': f"{avg_time:.2f}s",
            'error_rate': f"{(self.metrics['errors'] / max(self.metrics['total_requests'], 1) * 100):.2f}%",
            'cpu_usage': f"{psutil.cpu_percent()}%",
            'memory_usage': f"{psutil.virtual_memory().percent}%"
        }

# 사용
monitor = OllamaMonitor()

# 요청 처리
response = monitor.monitored_chat(
    model='llama2',
    messages=[{'role': 'user', 'content': '안녕?'}]
)

# 통계 확인
print(monitor.get_stats())

🎓 학습 리소스

🎬 마무리하며