# Install required packages
pip install transformers torch accelerate
pip install llama-cpp-python  # For CPU inference
pip install huggingface-hub

# For GPU acceleration
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
import json
from typing import List, Dict, Any

class Llama31Integration:
    def __init__(self, model_name: str = "meta-llama/Llama-3.1-8B-Instruct"):
        self.model_name = model_name
        self.tokenizer = None
        self.model = None
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
    
    def load_model(self):
        """Load the Llama 3.1 model and tokenizer"""
        print(f"Loading {self.model_name}...")
        
        self.tokenizer = AutoTokenizer.from_pretrained(
            self.model_name,
            trust_remote_code=True
        )
        
        self.model = AutoModelForCausalLM.from_pretrained(
            self.model_name,
            torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
            device_map="auto" if self.device == "cuda" else None,
            trust_remote_code=True
        )
        
        print(f"Model loaded on {self.device}")
    
    def generate_response(self, prompt: str, max_length: int = 512) -> str:
        """Generate a response using Llama 3.1"""
        if self.model is None or self.tokenizer is None:
            raise ValueError("Model not loaded. Call load_model() first.")
        
        # Format prompt for instruction-following
        formatted_prompt = f"<|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n{prompt}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"
        
        # Tokenize input
        inputs = self.tokenizer(
            formatted_prompt,
            return_tensors="pt",
            truncation=True,
            max_length=2048
        ).to(self.device)
        
        # Generate response
        with torch.no_grad():
            outputs = self.model.generate(
                **inputs,
                max_new_tokens=max_length,
                temperature=0.7,
                top_p=0.9,
                do_sample=True,
                pad_token_id=self.tokenizer.eos_token_id
            )
        
        # Decode response
        response = self.tokenizer.decode(
            outputs[0][inputs['input_ids'].shape[1]:],
            skip_special_tokens=True
        )
        
        return response.strip()

# Example usage
llama = Llama31Integration()
llama.load_model()

# Generate a response
response = llama.generate_response(
    "Explain the benefits of using microservices architecture in modern web applications."
)
print(response)

class LlamaChatBot:
    def __init__(self, model_name: str = "meta-llama/Llama-3.1-8B-Instruct"):
        self.llama = Llama31Integration(model_name)
        self.llama.load_model()
        self.conversation_history = []
    
    def add_message(self, role: str, content: str):
        """Add a message to conversation history"""
        self.conversation_history.append({
            "role": role,
            "content": content,
            "timestamp": datetime.now().isoformat()
        })
    
    def get_response(self, user_message: str) -> str:
        """Get AI response with conversation context"""
        self.add_message("user", user_message)
        
        # Build context from conversation history
        context = self._build_context()
        
        # Generate response
        response = self.llama.generate_response(context)
        
        # Add AI response to history
        self.add_message("assistant", response)
        
        return response
    
    def _build_context(self) -> str:
        """Build conversation context from history"""
        context_parts = []
        
        for message in self.conversation_history[-10:]:  # Last 10 messages
            if message["role"] == "user":
                context_parts.append(f"User: {message['content']}")
            else:
                context_parts.append(f"Assistant: {message['content']}")
        
        return "\n".join(context_parts)

# Usage example
chatbot = LlamaChatBot()

# Start conversation
response1 = chatbot.get_response("Hello! Can you help me with Python programming?")
print(f"AI: {response1}")

response2 = chatbot.get_response("I want to learn about async programming")
print(f"AI: {response2}")

class LlamaDocumentProcessor:
    def __init__(self, model_name: str = "meta-llama/Llama-3.1-8B-Instruct"):
        self.llama = Llama31Integration(model_name)
        self.llama.load_model()
    
    def summarize_document(self, text: str, max_length: int = 200) -> str:
        """Summarize a document using Llama 3.1"""
        prompt = f"""
        Please provide a concise summary of the following document in {max_length} words or less:
        
        {text}
        
        Summary:
        """
        
        return self.llama.generate_response(prompt, max_length)
    
    def extract_keywords(self, text: str) -> List[str]:
        """Extract keywords from text"""
        prompt = f"""
        Extract the most important keywords from this text. Return them as a comma-separated list:
        
        {text}
        
        Keywords:
        """
        
        response = self.llama.generate_response(prompt, max_length=100)
        return [keyword.strip() for keyword in response.split(",")]
    
    def classify_sentiment(self, text: str) -> Dict[str, float]:
        """Classify sentiment of text"""
        prompt = f"""
        Analyze the sentiment of this text and provide a score from -1 (very negative) to 1 (very positive):
        
        Text: {text}
        
        Provide your analysis in JSON format with 'sentiment' and 'confidence' fields.
        """
        
        response = self.llama.generate_response(prompt, max_length=150)
        
        try:
            # Parse JSON response
            result = json.loads(response)
            return result
        except json.JSONDecodeError:
            # Fallback parsing
            return {"sentiment": 0.0, "confidence": 0.5}

# Usage example
processor = LlamaDocumentProcessor()

# Process a document
document = """
Artificial Intelligence is transforming industries across the globe. 
From healthcare to finance, AI technologies are enabling new possibilities 
and improving efficiency. However, there are also concerns about job 
displacement and ethical implications that need to be addressed.
"""

summary = processor.summarize_document(document)
keywords = processor.extract_keywords(document)
sentiment = processor.classify_sentiment(document)

print(f"Summary: {summary}")
print(f"Keywords: {keywords}")
print(f"Sentiment: {sentiment}")

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional
import uvicorn

app = FastAPI(title="Llama 3.1 API", version="1.0.0")

# Global model instance
llama_model = None

class ChatRequest(BaseModel):
    message: str
    max_length: Optional[int] = 512
    temperature: Optional[float] = 0.7

class ChatResponse(BaseModel):
    response: str
    model: str
    timestamp: str

@app.on_event("startup")
async def startup_event():
    """Initialize the model on startup"""
    global llama_model
    llama_model = Llama31Integration()
    llama_model.load_model()

@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    """Chat endpoint"""
    if llama_model is None:
        raise HTTPException(status_code=500, detail="Model not loaded")
    
    try:
        response = llama_model.generate_response(
            request.message,
            request.max_length
        )
        
        return ChatResponse(
            response=response,
            model="Llama-3.1-8B",
            timestamp=datetime.now().isoformat()
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health_check():
    """Health check endpoint"""
    return {"status": "healthy", "model": "Llama-3.1-8B"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

# Dockerfile for Llama 3.1 API
FROM python:3.9-slim

WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

# Install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Expose port
EXPOSE 8000

# Run the application
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# docker-compose.yml
version: '3.8'

services:
  llama-api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - CUDA_VISIBLE_DEVICES=0
    volumes:
      - ./models:/app/models
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

from peft import LoraConfig, get_peft_model, TaskType
from transformers import TrainingArguments, Trainer
import torch

class LlamaFineTuner:
    def __init__(self, base_model_name: str = "meta-llama/Llama-3.1-8B-Instruct"):
        self.base_model_name = base_model_name
        self.model = None
        self.tokenizer = None
    
    def setup_lora(self):
        """Setup LoRA configuration for efficient fine-tuning"""
        lora_config = LoraConfig(
            task_type=TaskType.CAUSAL_LM,
            r=16,
            lora_alpha=32,
            lora_dropout=0.1,
            target_modules=["q_proj", "v_proj", "k_proj", "o_proj"]
        )
        
        self.model = get_peft_model(self.model, lora_config)
        return lora_config
    
    def prepare_training_data(self, dataset_path: str):
        """Prepare training dataset"""
        # Load and preprocess your custom dataset
        # This is a simplified example
        pass
    
    def train(self, training_args: TrainingArguments):
        """Fine-tune the model"""
        trainer = Trainer(
            model=self.model,
            args=training_args,
            train_dataset=self.train_dataset,
            eval_dataset=self.eval_dataset,
            tokenizer=self.tokenizer
        )
        
        trainer.train()
        return trainer

from transformers import BitsAndBytesConfig
import torch

def setup_quantization():
    """Setup model quantization for efficient inference"""
    quantization_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_compute_dtype=torch.float16,
        bnb_4bit_use_double_quant=True,
        bnb_4bit_quant_type="nf4"
    )
    
    return quantization_config

# Usage
quantization_config = setup_quantization()
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B-Instruct",
    quantization_config=quantization_config,
    device_map="auto"
)

import redis
from functools import lru_cache

class OptimizedLlamaIntegration:
    def __init__(self, redis_url: str = "redis://localhost:6379"):
        self.llama = Llama31Integration()
        self.llama.load_model()
        self.redis_client = redis.from_url(redis_url)
    
    @lru_cache(maxsize=1000)
    def cached_generate(self, prompt: str, max_length: int) -> str:
        """Cache generated responses"""
        cache_key = f"llama:{hash(prompt)}:{max_length}"
        
        # Check cache first
        cached_response = self.redis_client.get(cache_key)
        if cached_response:
            return cached_response.decode('utf-8')
        
        # Generate new response
        response = self.llama.generate_response(prompt, max_length)
        
        # Cache the response
        self.redis_client.setex(cache_key, 3600, response)  # 1 hour TTL
        
        return response

import logging
from prometheus_client import Counter, Histogram, start_http_server

# Metrics
REQUEST_COUNT = Counter('llama_requests_total', 'Total requests')
REQUEST_DURATION = Histogram('llama_request_duration_seconds', 'Request duration')

class ProductionLlamaAPI:
    def __init__(self):
        self.llama = Llama31Integration()
        self.llama.load_model()
        self.setup_logging()
        self.setup_metrics()
    
    def setup_logging(self):
        """Setup structured logging"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
        )
        self.logger = logging.getLogger(__name__)
    
    def setup_metrics(self):
        """Setup Prometheus metrics"""
        start_http_server(8001)  # Metrics endpoint
    
    def generate_with_monitoring(self, prompt: str) -> str:
        """Generate response with monitoring"""
        REQUEST_COUNT.inc()
        
        with REQUEST_DURATION.time():
            response = self.llama.generate_response(prompt)
        
        self.logger.info(f"Generated response for prompt: {prompt[:50]}...")
        return response