Mistral AI offers two methods: using the cloud API and directly deploying the weights of open models on a local GPU through the `mistral-inference` library.

### 4-1. Quick Start (Using the Cloud API)

This method involves obtaining an API key from La Plateforme, Mistral AI's cloud platform, and then easily calling the API using the Python SDK.

```bash
# Install the official Mistral AI Python SDK
pip install mistralai
```

After installation, you can integrate the model in your Python code as follows:

```python
import os
from mistralai import Mistral

# Set the API key (register the key in an environment variable or enter it in the code)
api_key = os.environ.get("MISTRAL_API_KEY", "your_api_key_here")

# Create a client object
client = Mistral(api_key=api_key)

# Create a chat request using the latest Mistral Large model
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": "Explain the protein functional differences between BRCA1 and BRCA2, which are genes that cause breast cancer, in a friendly manner in Korean."}
    ]
)

print(response.choices[0].message.content)
```

### 4-2. Detailed Installation (Directly Serving Mistral Models on a Local GPU)

This method involves downloading the weights locally for use in extremely security-sensitive research environments and directly running them using the `mistral-inference` package.

```bash
# Install the official mistral-inference and huggingface-hub packages for local inference
pip install mistral-inference huggingface_hub
```

After that, download the model from Hugging Face and run the inference as shown below.

```python
from huggingface_hub import snapshot_download
from pathlib import Path
from mistral_inference.transformer import Transformer
from mistral_common.tokens.tokenizers.mistral import MistralTokenizer
from mistral_common.protocol.instruct.messages import UserMessage
from mistral_common.protocol.instruct.request import ChatCompletionRequest

# 1. Download model weights and tokenizer locally (e.g., Mistral-7B-Instruct-v0.3)
mistral_models_path = Path.home() / "mistral_models"
mistral_models_path.mkdir(parents=True, exist_ok=True)

snapshot_download(
    repo_id="mistralai/Mistral-7B-Instruct-v0.3", 
    allow_patterns=["params.json", "consolidated.safetensors", "tokenizer.model.v3"], 
    local_dir=mistral_models_path
)

# 2. Load the tokenizer and transformer model (CUDA environment required)
tokenizer = MistralTokenizer.from_file(str(mistral_models_path / "tokenizer.model.v3"))
model = Transformer.from_folder(mistral_models_path)

# 3. Tokenize the input data and run local inference
completion_request = ChatCompletionRequest(messages=[UserMessage(content="Explain CRISPR-Cas9 mechanism shortly.")])
tokens = tokenizer.encode_chat_completion(completion_request).tokens

out_tokens, _ = model.generate(tokens, max_tokens=256, temperature=0.35)
result = tokenizer.decode(out_tokens)
print(result)
```