from vllm import LLM, SamplingParams

llm = LLM(
    model="meta-llama/Llama-3.1-8B-Instruct",
    tensor_parallel_size=1,
    gpu_memory_utilization=0.9,
    max_num_batched_tokens=8192,
    enable_prefix_caching=True
)

sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.95,
    max_tokens=512
)

prompts = [
    "Explain machine learning in simple terms",
    "What is the capital of France?",
    "Write a haiku about coding",
]

# vLLM automáticamente hace continuous batching
outputs = llm.generate(prompts, sampling_params)

# Con continuous batching:
# - 1000 requests en ~30 segundos
# - GPU utilization >90%
# - Coste reducido ~50%

from vllm import LLM, SamplingParams

llm = LLM(
    model="meta-llama/Llama-3.1-70B-Instruct",
    gpu_memory_utilization=0.90,
    max_num_seqs=256,
    block_size=16,
    swap_space=4,
    enable_prefix_caching=True,
)

# Con prefix caching, si muchas queries comparten system prompt:
# Query 1: [system prompt] + "¿Qué es X?"
# Query 2: [system prompt] + "¿Cómo funciona Y?"
# El KV cache del system prompt se comparte = menos memoria

from llmlingua import PromptCompressor

compressor = PromptCompressor(
    model_name="microsoft/llmlingua-2-xlm-roberta-large-meetingbank",
    use_llmlingua2=True
)

original_prompt = "[Contexto de 5000 tokens aquí...]"

compressed = compressor.compress_prompt(
    original_prompt,
    rate=0.5,  # Comprimir al 50%
)

print(f"Original: {len(original_prompt.split())} palabras")
print(f"Comprimido: {len(compressed['compressed_prompt'].split())}")

# Resultado: misma calidad, 50% menos tokens = 50% menos coste

import openai

# Configurar cliente para OpenRouter
client = openai.OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="tu-api-key-openrouter"
)

def route_query(query: str, complexity: str = "auto"):
    """
    Enruta queries al modelo óptimo según complejidad.
    """
    model_tiers = {
        "simple": "meta-llama/llama-3.2-1b-instruct:free",
        "medium": "anthropic/claude-3.5-haiku",
        "complex": "anthropic/claude-3.5-sonnet",
        "reasoning": "openai/o1-preview"
    }

    if complexity == "auto":
        if len(query) < 50 and not any(kw in query.lower()
            for kw in ["analiza", "compara", "explica detalladamente"]):
            complexity = "simple"
        elif len(query) < 200:
            complexity = "medium"
        else:
            complexity = "complex"

    response = client.chat.completions.create(
        model=model_tiers[complexity],
        messages=[{"role": "user", "content": query}]
    )

    return {
        "response": response.choices[0].message.content,
        "model_used": model_tiers[complexity]
    }

# Uso
result = route_query("¿Cuál es el horario de atención?")
print(f"Modelo: {result['model_used']}")  # llama-3.2-1b (gratis!)

from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig

# Cargar modelo con quantization GPTQ
model_id = "TheBloke/Llama-2-70B-GPTQ"

quantization_config = GPTQConfig(
    bits=4,                    # INT4 quantization
    group_size=128,
    desc_act=True,
    use_exllama=True           # Backend optimizado
)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=quantization_config,
    device_map="auto"
)

tokenizer = AutoTokenizer.from_pretrained(model_id)

# Inference normal - pero 4x menos memoria!
inputs = tokenizer("Explain inference optimization", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=200)
print(tokenizer.decode(outputs[0]))

from gptcache import cache
from gptcache.adapter import openai
from gptcache.embedding import Onnx
from gptcache.manager import CacheBase, VectorBase, get_data_manager
import redis

redis_client = redis.Redis(host='localhost', port=6379, db=0)

onnx = Onnx()
vector_base = VectorBase(
    "redis",
    host="localhost",
    port=6379,
    dimension=onnx.dimension
)

data_manager = get_data_manager(
    CacheBase("sqlite"),
    vector_base
)

cache.init(
    embedding_func=onnx.to_embeddings,
    data_manager=data_manager,
)

cache.config.similarity_threshold = 0.88

def cached_completion(prompt: str):
    response = openai.ChatCompletion.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

# Primera llamada - va a OpenAI, se cachea
result1 = cached_completion("¿Cuál es el precio?")

# Segunda llamada - semánticamente similar, viene de cache (GRATIS!)
result2 = cached_completion("What's your pricing?")