Mistral AI 완전 가이드

Mistral 소개

2023년 설립된 프랑스 스타트업 Mistral AI는 첫 모델 Mistral 7B를 공개하자마자 같은 크기 모델 대비 최고 성능으로 화제를 모았습니다. Sliding Window Attention과 Grouped Query Attention으로 메모리 효율을 극대화했으며, Apache 2.0 라이선스로 상업적 사용이 완전히 자유롭습니다.

모델 라인업

Ollama로 실행

# Mistral 7B
ollama run mistral

# Mistral NeMo 12B
ollama run mistral-nemo

# Mixtral 8x7B (24GB+ VRAM 필요)
ollama run mixtral

# Mixtral 8x22B
ollama run mixtral:8x22bbash

Hugging Face 활용

pip install transformers torch accelerate

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "mistralai/Mistral-7B-Instruct-v0.3"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto",
)

# Mistral Instruct 형식 프롬프트
messages = [
    {"role": "user", "content": "Python과 Go의 차이점을 설명해주세요."},
]

# 템플릿 적용
encodeds = tokenizer.apply_chat_template(
    messages,
    return_tensors="pt",
    add_generation_prompt=True,
)

outputs = model.generate(
    encodeds.to(model.device),
    max_new_tokens=512,
    temperature=0.7,
    do_sample=True,
    pad_token_id=tokenizer.eos_token_id,
)
decoded = tokenizer.decode(outputs[0][encodeds.shape[1]:], skip_special_tokens=True)
print(decoded)python

Mistral AI 공식 API

pip install mistralai

from mistralai import Mistral

client = Mistral(api_key="YOUR_MISTRAL_API_KEY")

# 텍스트 생성
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "system", "content": "당신은 친절한 AI 어시스턴트입니다."},
        {"role": "user",   "content": "마이크로서비스 아키텍처의 장단점은?"},
    ],
    temperature=0.7,
    max_tokens=1024,
)
print(response.choices[0].message.content)

# 스트리밍
with client.chat.stream(
    model="mistral-small-latest",
    messages=[{"role": "user", "content": "짧은 Python 튜토리얼을 작성해주세요."}],
) as stream:
    for chunk in stream:
        print(chunk.data.choices[0].delta.content or "", end="")python

Function Calling (도구 사용)

Mistral은 Function Calling을 기본 지원합니다. 외부 API, 데이터베이스 조회 등을 LLM과 연결할 수 있습니다.

from mistralai import Mistral
import json

client = Mistral(api_key="YOUR_API_KEY")

# 도구 정의
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "특정 도시의 현재 날씨를 조회합니다.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "도시 이름 (예: 서울)"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                },
                "required": ["city"],
            },
        },
    }
]

messages = [{"role": "user", "content": "서울과 부산의 현재 날씨를 알려주세요."}]

# 1단계: 모델이 함수 호출 결정
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

# 2단계: 함수 실행
tool_call = response.choices[0].message.tool_calls[0]
function_name = tool_call.function.name
arguments = json.loads(tool_call.function.arguments)

# 실제 날씨 API 호출 (예시)
def get_weather(city, unit="celsius"):
    return {"city": city, "temperature": 22, "condition": "맑음", "unit": unit}

result = get_weather(**arguments)

# 3단계: 결과를 다시 모델에 전달
messages.append(response.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": json.dumps(result, ensure_ascii=False),
})

final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
)
print(final_response.choices[0].message.content)python

Python 실용 패턴

비동기 처리

import asyncio
from mistralai import Mistral

async def generate_parallel(queries: list[str]):
    client = Mistral(api_key="YOUR_API_KEY")

    async def single_query(q):
        resp = await client.chat.complete_async(
            model="mistral-small-latest",
            messages=[{"role": "user", "content": q}],
        )
        return resp.choices[0].message.content

    results = await asyncio.gather(*[single_query(q) for q in queries])
    return results

queries = ["Python이란?", "Go란?", "Rust란?"]
results = asyncio.run(generate_parallel(queries))
for q, r in zip(queries, results):
    print(f"Q: {q}\nA: {r[:100]}...\n")python

RAG 구현

from mistralai import Mistral

client = Mistral(api_key="YOUR_API_KEY")

# Mistral Embeddings API 활용
def embed_texts(texts: list[str]):
    response = client.embeddings.create(
        model="mistral-embed",
        inputs=texts,
    )
    return [e.embedding for e in response.data]

# 문서 임베딩
docs = [
    "TestForge는 개발자를 위한 부하 테스트 플랫폼입니다.",
    "k6는 JavaScript로 성능 테스트를 작성하는 도구입니다.",
    "nGrinder는 분산 부하 테스트를 지원합니다.",
]
doc_embeddings = embed_texts(docs)

# 코사인 유사도 검색
import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def retrieve(query, k=2):
    q_emb = embed_texts([query])[0]
    scores = [cosine_similarity(q_emb, d) for d in doc_embeddings]
    top_k = sorted(enumerate(scores), key=lambda x: x[1], reverse=True)[:k]
    return [docs[i] for i, _ in top_k]

# RAG 파이프라인
query = "성능 테스트 도구를 추천해주세요."
context = "\n".join(retrieve(query))

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "system", "content": f"컨텍스트:\n{context}\n\n위 정보를 기반으로 답변하세요."},
        {"role": "user",   "content": query},
    ],
)
print(response.choices[0].message.content)python

Mixtral MoE 아키텍처

Mixtral 8x7B는 8개의 전문가(Expert) 네트워크 중 토큰마다 2개를 선택해 활성화하는 Mixture of Experts(MoE) 아키텍처를 사용합니다. 전체 파라미터는 ~47B이지만 실제 연산은 ~13B 수준으로 효율적입니다.

성능 벤치마크