Local AI Development in 2025

local_models_2025:
  llama_3_1:
    sizes: [8B, 70B]
    requirements:
      8B: "8GB RAM, runs on CPU"
      70B: "48GB+ VRAM or quantized"
    quality: "Near GPT-4 for many tasks"

  mistral:
    sizes: [7B, "8x7B"]
    requirements:
      7B: "8GB RAM"
    quality: "Efficient, strong reasoning"

  phi_3:
    sizes: [3.8B]
    requirements: "4GB RAM"
    quality: "Impressive for size"

  qwen:
    sizes: [7B, 14B, 72B]
    quality: "Strong multilingual"

  code_models:
    codellama: "Code-focused Llama"
    deepseek_coder: "Strong coding capability"

# Ollama - easiest way to run local models
curl -fsSL https://ollama.com/install.sh | sh

# Pull and run a model
ollama pull llama3.1:8b
ollama run llama3.1:8b

# For code
ollama pull codellama:13b

# Using Ollama from Python
import ollama

response = ollama.chat(
    model='llama3.1:8b',
    messages=[
        {'role': 'user', 'content': 'Explain recursion simply'}
    ]
)
print(response['message']['content'])

# Streaming
for chunk in ollama.chat(
    model='llama3.1:8b',
    messages=[{'role': 'user', 'content': 'Write a haiku'}],
    stream=True
):
    print(chunk['message']['content'], end='', flush=True)

class LocalAIDev:
    """Development environment with local AI."""

    def __init__(self, model: str = "llama3.1:8b"):
        self.model = model
        self.client = ollama.Client()

    async def generate(
        self,
        prompt: str,
        system: str = None
    ) -> str:
        messages = []
        if system:
            messages.append({"role": "system", "content": system})
        messages.append({"role": "user", "content": prompt})

        response = self.client.chat(
            model=self.model,
            messages=messages
        )

        return response["message"]["content"]

    async def generate_with_fallback(
        self,
        prompt: str,
        cloud_client = None
    ) -> str:
        """Try local first, fall back to cloud."""
        try:
            return await self.generate(prompt)
        except Exception as e:
            if cloud_client:
                return await cloud_client.generate(prompt)
            raise

hybrid_strategy:
  local_for:
    - Development and testing
    - Privacy-sensitive data
    - Offline scenarios
    - Cost optimization

  cloud_for:
    - Best quality when needed
    - Production (usually)
    - Complex tasks
    - Fallback

  implementation:
    - Same interface for both
    - Easy switching
    - Cost tracking

class ModelSelector:
    """Select appropriate model for task."""

    def select(self, task: Task) -> ModelConfig:
        if task.requires_best_quality:
            return ModelConfig(
                provider="cloud",
                model="claude-3-5-sonnet"
            )

        if task.privacy_required:
            return ModelConfig(
                provider="local",
                model="llama3.1:8b"
            )

        if task.is_coding:
            return ModelConfig(
                provider="local",
                model="codellama:13b"
            )

        # Default: local for cost
        return ModelConfig(
            provider="local",
            model="llama3.1:8b"
        )

local_optimization:
  quantization:
    purpose: "Reduce memory, increase speed"
    options: ["Q4_0", "Q4_K_M", "Q5_K_M", "Q8_0"]
    tradeoff: "Lower quantization = faster but less accurate"

  gpu_acceleration:
    nvidia: "CUDA support in Ollama"
    apple: "Metal support built-in"
    benefit: "10-50x faster than CPU"

  batching:
    purpose: "Process multiple requests efficiently"
    how: "vLLM, TGI for production local"