Modern Large Language Models: Architecture, Fine-Tuning, and Production Deployment

Note: This guide is based on the original “Attention Is All You Need” paper (Vaswani et al., 2017), Hugging Face Transformers documentation, and production patterns from LLM providers including OpenAI, Anthropic, and Meta. All code examples use documented APIs and follow industry best practices for LLM deployment.

Large Language Models (LLMs) have evolved from academic curiosities to production systems powering ChatGPT, Claude, GitHub Copilot, and enterprise search. Built on the transformer architecture, modern LLMs contain billions of parameters and demonstrate emergent capabilities including reasoning, code generation, and multi-turn conversation.

This guide covers transformer architecture fundamentals, the modern LLM landscape (GPT-4, Claude 3, Llama 3), Retrieval Augmented Generation (RAG) for grounding responses in external knowledge, fine-tuning techniques, and production deployment patterns.

Prerequisites

Required Knowledge:

Python 3.8+ programming
Basic understanding of neural networks (layers, backpropagation, loss functions)
Familiarity with NLP concepts (tokenization, embeddings)
Understanding of REST APIs

Required Tools:

# Install core libraries
pip install transformers==4.36.0  # Hugging Face transformers
pip install torch==2.1.0  # PyTorch for model training
pip install datasets==2.16.0  # Hugging Face datasets

# Install LLM API clients
pip install openai==1.6.0  # OpenAI GPT-4
pip install anthropic==0.8.0  # Anthropic Claude

# Install vector database for RAG
pip install chromadb==0.4.22  # Vector database
pip install sentence-transformers==2.2.2  # Embeddings

# Install fine-tuning libraries
pip install peft==0.7.0  # Parameter-Efficient Fine-Tuning (LoRA)
pip install bitsandbytes==0.41.0  # 8-bit quantization

# Install evaluation libraries
pip install rouge-score==0.1.2  # Text generation evaluation
pip install bert-score==0.3.13  # Semantic similarity

# Install API framework
pip install fastapi==0.109.0 uvicorn==0.27.0

Transformer Architecture Deep Dive

The Self-Attention Mechanism

The transformer architecture’s breakthrough was the self-attention mechanism, which allows models to weigh the importance of different words in a sequence when processing each word.

Attention Formula:

Attention(Q, K, V) = softmax((Q * K^T) / √d_k) * V

Where:

Q (Query): “What am I looking for?”
K (Key): “What do I contain?”
V (Value): “What information do I have?”
d_k: Dimension of keys (scaling factor)

Intuition: For the sentence “The cat sat on the mat”, when processing “sat”, attention helps the model focus on “cat” (subject) and “mat” (object), understanding the relationship between words.

Multi-Head Attention

# multi_head_attention.py - Simplified transformer attention
import torch
import torch.nn as nn
import math

class MultiHeadAttention(nn.Module):
    """
    Multi-Head Attention mechanism
    Allows model to jointly attend to information from different representation subspaces
    """

    def __init__(self, d_model: int = 512, num_heads: int = 8, dropout: float = 0.1):
        """
        Args:
            d_model: Model dimension (embedding size)
            num_heads: Number of attention heads
            dropout: Dropout rate
        """
        super().__init__()
        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"

        self.d_model = d_model
        self.num_heads = num_heads
        self.d_k = d_model // num_heads  # Dimension per head

        # Linear projections for Q, K, V
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)

        # Output projection
        self.W_o = nn.Linear(d_model, d_model)

        self.dropout = nn.Dropout(dropout)

    def scaled_dot_product_attention(
        self,
        Q: torch.Tensor,
        K: torch.Tensor,
        V: torch.Tensor,
        mask: torch.Tensor = None
    ) -> torch.Tensor:
        """
        Compute scaled dot-product attention

        Args:
            Q: Query tensor (batch_size, num_heads, seq_len, d_k)
            K: Key tensor (batch_size, num_heads, seq_len, d_k)
            V: Value tensor (batch_size, num_heads, seq_len, d_k)
            mask: Optional attention mask

        Returns:
            Attention output and attention weights
        """
        # Compute attention scores
        # (batch_size, num_heads, seq_len_q, d_k) @ (batch_size, num_heads, d_k, seq_len_k)
        # -> (batch_size, num_heads, seq_len_q, seq_len_k)
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)

        # Apply mask (for causal attention in GPT)
        if mask is not None:
            scores = scores.masked_fill(mask == 0, float('-inf'))

        # Apply softmax to get attention weights
        attention_weights = torch.softmax(scores, dim=-1)
        attention_weights = self.dropout(attention_weights)

        # Apply attention weights to values
        # (batch_size, num_heads, seq_len_q, seq_len_k) @ (batch_size, num_heads, seq_len_k, d_k)
        # -> (batch_size, num_heads, seq_len_q, d_k)
        output = torch.matmul(attention_weights, V)

        return output, attention_weights

    def forward(self, query: torch.Tensor, key: torch.Tensor, value: torch.Tensor, mask: torch.Tensor = None):
        """
        Forward pass

        Args:
            query: Query tensor (batch_size, seq_len, d_model)
            key: Key tensor (batch_size, seq_len, d_model)
            value: Value tensor (batch_size, seq_len, d_model)
            mask: Optional attention mask
        """
        batch_size = query.size(0)

        # Linear projections in batch
        Q = self.W_q(query)  # (batch_size, seq_len, d_model)
        K = self.W_k(key)
        V = self.W_v(value)

        # Split into multiple heads
        # (batch_size, seq_len, d_model) -> (batch_size, seq_len, num_heads, d_k)
        # -> (batch_size, num_heads, seq_len, d_k)
        Q = Q.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        K = K.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        V = V.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)

        # Apply attention
        attention_output, attention_weights = self.scaled_dot_product_attention(Q, K, V, mask)

        # Concatenate heads
        # (batch_size, num_heads, seq_len, d_k) -> (batch_size, seq_len, num_heads, d_k)
        # -> (batch_size, seq_len, d_model)
        attention_output = attention_output.transpose(1, 2).contiguous().view(
            batch_size, -1, self.d_model
        )

        # Final linear projection
        output = self.W_o(attention_output)

        return output, attention_weights

Positional Encoding

Transformers have no inherent sense of word order. Positional encodings add position information:

# positional_encoding.py - Add position information to embeddings
import torch
import torch.nn as nn
import math

class PositionalEncoding(nn.Module):
    """
    Inject position information into token embeddings
    Uses sine and cosine functions of different frequencies
    """

    def __init__(self, d_model: int, max_len: int = 5000, dropout: float = 0.1):
        """
        Args:
            d_model: Embedding dimension
            max_len: Maximum sequence length
            dropout: Dropout rate
        """
        super().__init__()
        self.dropout = nn.Dropout(dropout)

        # Create positional encoding matrix
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)

        # Compute the positional encodings once in log space
        div_term = torch.exp(
            torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)
        )

        # Apply sine to even indices
        pe[:, 0::2] = torch.sin(position * div_term)

        # Apply cosine to odd indices
        pe[:, 1::2] = torch.cos(position * div_term)

        pe = pe.unsqueeze(0)  # Add batch dimension
        self.register_buffer('pe', pe)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """
        Add positional encoding to input embeddings

        Args:
            x: Input embeddings (batch_size, seq_len, d_model)

        Returns:
            Embeddings with positional information
        """
        x = x + self.pe[:, :x.size(1), :]
        return self.dropout(x)

Modern LLM Landscape

Decoder-Only vs Encoder-Only vs Encoder-Decoder

Architecture	Models	Use Case	How It Works
Encoder-Only	BERT, RoBERTa	Classification, embeddings	Bidirectional context, good for understanding
Decoder-Only	GPT-4, Claude, Llama	Text generation, chat	Causal (left-to-right) attention, generates token by token
Encoder-Decoder	T5, BART	Translation, summarization	Encoder processes input, decoder generates output

2025 LLM Comparison

Model	Parameters	Context Length	Strengths	Provider
GPT-4 Turbo	~1.7T (estimated)	128K tokens	Best reasoning, code, math	OpenAI
Claude 3 Opus	Unknown	200K tokens	Best writing quality, safety	Anthropic
Llama 3 70B	70B	8K tokens	Open source, efficient	Meta
Mistral 7B	7B	8K tokens	Fast, runs locally	Mistral AI
Gemini Ultra	Unknown	32K tokens	Multimodal (text, images, video)	Google

Using Modern LLMs via APIs

OpenAI GPT-4

# openai_example.py - Using GPT-4 for text generation
from openai import OpenAI
import os

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def generate_with_gpt4(
    prompt: str,
    system_message: str = "You are a helpful assistant.",
    temperature: float = 0.7,
    max_tokens: int = 1000
) -> str:
    """
    Generate text using GPT-4

    Args:
        prompt: User prompt
        system_message: System instructions
        temperature: Randomness (0-2, higher = more random)
        max_tokens: Maximum tokens to generate

    Returns:
        Generated text
    """
    response = client.chat.completions.create(
        model="gpt-4-turbo-preview",
        messages=[
            {"role": "system", "content": system_message},
            {"role": "user", "content": prompt}
        ],
        temperature=temperature,
        max_tokens=max_tokens,
        top_p=1.0,
        frequency_penalty=0.0,
        presence_penalty=0.0
    )

    return response.choices[0].message.content


# Example: Code generation
code_prompt = """Write a Python function to find the longest palindromic substring
in a given string using dynamic programming. Include docstring and type hints."""

code = generate_with_gpt4(
    prompt=code_prompt,
    system_message="You are an expert Python programmer. Write clean, well-documented code.",
    temperature=0.2  # Lower temperature for code generation
)

print(code)

Anthropic Claude

# anthropic_example.py - Using Claude for analysis
from anthropic import Anthropic
import os

client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def analyze_with_claude(
    text: str,
    task: str,
    max_tokens: int = 2000
) -> str:
    """
    Analyze text using Claude

    Args:
        text: Text to analyze
        task: Analysis task description
        max_tokens: Maximum tokens to generate

    Returns:
        Analysis result
    """
    message = client.messages.create(
        model="claude-3-opus-20240229",
        max_tokens=max_tokens,
        messages=[
            {
                "role": "user",
                "content": f"{task}\n\nText to analyze:\n{text}"
            }
        ]
    )

    return message.content[0].text


# Example: Sentiment analysis
review = """This product exceeded my expectations! The build quality is fantastic,
and the customer service was responsive when I had questions. Highly recommend."""

sentiment = analyze_with_claude(
    text=review,
    task="Analyze the sentiment of this product review. Provide: 1) Overall sentiment (positive/negative/neutral), 2) Key aspects mentioned, 3) Confidence score."
)

print(sentiment)

Retrieval Augmented Generation (RAG)

RAG grounds LLM responses in external knowledge, reducing hallucinations and enabling answers from proprietary documents.

RAG Architecture

1. User Query → 2. Embed Query → 3. Search Vector DB → 4. Retrieve Relevant Docs
   ↓
5. Combine Query + Docs → 6. LLM Generation → 7. Response

Building a Production RAG System

# rag_system.py - Complete RAG implementation
from sentence_transformers import SentenceTransformer
import chromadb
from openai import OpenAI
from typing import List, Dict
import os

class RAGSystem:
    """
    Retrieval Augmented Generation system
    Combines document retrieval with LLM generation
    """

    def __init__(
        self,
        collection_name: str = "knowledge_base",
        embedding_model: str = "all-MiniLM-L6-v2",
        llm_model: str = "gpt-4-turbo-preview"
    ):
        """
        Args:
            collection_name: ChromaDB collection name
            embedding_model: Sentence transformer model
            llm_model: OpenAI model name
        """
        # Initialize embedding model
        self.embedder = SentenceTransformer(embedding_model)

        # Initialize vector database
        self.chroma_client = chromadb.Client()
        self.collection = self.chroma_client.get_or_create_collection(
            name=collection_name,
            metadata={"hnsw:space": "cosine"}  # Cosine similarity
        )

        # Initialize LLM client
        self.llm_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
        self.llm_model = llm_model

    def add_documents(self, documents: List[Dict[str, str]]) -> None:
        """
        Add documents to vector database

        Args:
            documents: List of dicts with 'id', 'text', 'metadata'
        """
        texts = [doc['text'] for doc in documents]
        ids = [doc['id'] for doc in documents]
        metadatas = [doc.get('metadata', {}) for doc in documents]

        # Generate embeddings
        embeddings = self.embedder.encode(texts).tolist()

        # Add to vector database
        self.collection.add(
            documents=texts,
            embeddings=embeddings,
            ids=ids,
            metadatas=metadatas
        )

    def retrieve(self, query: str, n_results: int = 5) -> List[Dict]:
        """
        Retrieve relevant documents for query

        Args:
            query: Search query
            n_results: Number of results to return

        Returns:
            List of relevant documents with metadata
        """
        # Embed query
        query_embedding = self.embedder.encode(query).tolist()

        # Search vector database
        results = self.collection.query(
            query_embeddings=[query_embedding],
            n_results=n_results
        )

        # Format results
        documents = []
        for i in range(len(results['ids'][0])):
            documents.append({
                'id': results['ids'][0][i],
                'text': results['documents'][0][i],
                'metadata': results['metadatas'][0][i],
                'distance': results['distances'][0][i] if 'distances' in results else None
            })

        return documents

    def generate_answer(
        self,
        query: str,
        context_documents: List[Dict],
        system_message: str = "You are a helpful assistant that answers questions based on the provided context."
    ) -> str:
        """
        Generate answer using LLM with retrieved context

        Args:
            query: User question
            context_documents: Retrieved documents
            system_message: System prompt

        Returns:
            Generated answer
        """
        # Build context from retrieved documents
        context = "\n\n---\n\n".join([
            f"Source {i+1}:\n{doc['text']}"
            for i, doc in enumerate(context_documents)
        ])

        # Create prompt
        prompt = f"""Answer the following question using ONLY the information provided in the context below. If the context doesn't contain enough information to answer the question, say "I don't have enough information to answer that question."

Context:
{context}

Question: {query}

Answer:"""

        # Generate response
        response = self.llm_client.chat.completions.create(
            model=self.llm_model,
            messages=[
                {"role": "system", "content": system_message},
                {"role": "user", "content": prompt}
            ],
            temperature=0.3,  # Lower temperature for factual answers
            max_tokens=500
        )

        return response.choices[0].message.content

    def query(self, question: str, n_results: int = 5) -> Dict:
        """
        End-to-end RAG: retrieve documents and generate answer

        Args:
            question: User question
            n_results: Number of documents to retrieve

        Returns:
            Dict with answer and source documents
        """
        # Retrieve relevant documents
        documents = self.retrieve(question, n_results=n_results)

        # Generate answer
        answer = self.generate_answer(question, documents)

        return {
            'answer': answer,
            'sources': documents
        }


# Example usage
if __name__ == "__main__":
    # Initialize RAG system
    rag = RAGSystem()

    # Add knowledge base documents
    documents = [
        {
            'id': 'doc1',
            'text': 'The capital of France is Paris. Paris is known for the Eiffel Tower and the Louvre Museum.',
            'metadata': {'source': 'geography_facts.txt', 'topic': 'geography'}
        },
        {
            'id': 'doc2',
            'text': 'Python is a high-level programming language created by Guido van Rossum in 1991.',
            'metadata': {'source': 'programming_facts.txt', 'topic': 'programming'}
        },
        {
            'id': 'doc3',
            'text': 'The Transformer architecture was introduced in the paper "Attention Is All You Need" by Vaswani et al. in 2017.',
            'metadata': {'source': 'ai_history.txt', 'topic': 'AI'}
        }
    ]

    rag.add_documents(documents)

    # Query the system
    result = rag.query("What is the Transformer architecture?")

    print("Answer:", result['answer'])
    print("\nSources:")
    for source in result['sources']:
        print(f"- {source['metadata']['source']}: {source['text'][:100]}...")

Fine-Tuning LLMs with LoRA

LoRA (Low-Rank Adaptation) enables efficient fine-tuning by training small adapter layers instead of the entire model.

LoRA Benefits

Aspect	Full Fine-Tuning	LoRA Fine-Tuning
Parameters Trained	7B-70B	0.1% (millions)
GPU Memory	80+ GB	16-24 GB
Training Time	Days	Hours
Storage	Full model copy per task	Small adapter per task

Fine-Tuning Llama with LoRA

# lora_finetuning.py - Fine-tune Llama with LoRA
from transformers import (
    AutoModel Tokenizer,
    AutoModelForCausalLM,
    TrainingArguments,
    Trainer
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from datasets import load_dataset
import torch

def finetune_llama_lora(
    base_model: str = "meta-llama/Llama-2-7b-hf",
    dataset_name: str = "squad",
    output_dir: str = "./llama-lora-finetuned",
    lora_r: int = 8,
    lora_alpha: int = 16,
    lora_dropout: float = 0.05
):
    """
    Fine-tune Llama model with LoRA for question answering

    Args:
        base_model: Hugging Face model ID
        dataset_name: Dataset for training
        output_dir: Directory to save adapter weights
        lora_r: LoRA rank (lower = fewer parameters)
        lora_alpha: LoRA scaling factor
        lora_dropout: Dropout rate for LoRA layers
    """
    # Load tokenizer
    tokenizer = AutoTokenizer.from_pretrained(base_model)
    tokenizer.pad_token = tokenizer.eos_token

    # Load model with 8-bit quantization (reduces memory)
    model = AutoModelForCausalLM.from_pretrained(
        base_model,
        load_in_8bit=True,
        device_map="auto",
        torch_dtype=torch.float16
    )

    # Prepare model for k-bit training
    model = prepare_model_for_kbit_training(model)

    # Configure LoRA
    lora_config = LoraConfig(
        r=lora_r,  # Rank of update matrices
        lora_alpha=lora_alpha,  # Scaling factor
        target_modules=["q_proj", "v_proj"],  # Which layers to adapt
        lora_dropout=lora_dropout,
        bias="none",
        task_type="CAUSAL_LM"
    )

    # Add LoRA adapters to model
    model = get_peft_model(model, lora_config)

    # Print trainable parameters
    model.print_trainable_parameters()
    # Output: trainable params: 4,194,304 || all params: 6,742,609,920 || trainable%: 0.0622

    # Load and preprocess dataset
    dataset = load_dataset(dataset_name, split="train[:1000]")  # Use subset for demo

    def tokenize_function(examples):
        # Format as instruction following
        prompts = [
            f"Context: {context}\n\nQuestion: {question}\n\nAnswer: {answer}"
            for context, question, answer in zip(
                examples['context'],
                examples['question'],
                examples['answers']['text'][0]
            )
        ]

        return tokenizer(
            prompts,
            truncation=True,
            max_length=512,
            padding="max_length"
        )

    tokenized_dataset = dataset.map(tokenize_function, batched=True)

    # Training arguments
    training_args = TrainingArguments(
        output_dir=output_dir,
        num_train_epochs=3,
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        learning_rate=2e-4,
        fp16=True,  # Mixed precision training
        logging_steps=10,
        save_steps=100,
        evaluation_strategy="no",
        warmup_steps=100,
        optim="paged_adamw_8bit"  # 8-bit optimizer
    )

    # Initialize trainer
    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=tokenized_dataset,
        tokenizer=tokenizer
    )

    # Train model
    trainer.train()

    # Save LoRA adapters (only ~10MB!)
    model.save_pretrained(output_dir)
    tokenizer.save_pretrained(output_dir)

    print(f"LoRA adapters saved to {output_dir}")


# Load fine-tuned model for inference
def load_finetuned_model(base_model: str, adapter_path: str):
    """Load base model with trained LoRA adapters"""
    from peft import PeftModel

    tokenizer = AutoTokenizer.from_pretrained(base_model)
    model = AutoModelForCausalLM.from_pretrained(
        base_model,
        load_in_8bit=True,
        device_map="auto"
    )

    # Load LoRA adapters
    model = PeftModel.from_pretrained(model, adapter_path)

    return model, tokenizer

Prompt Engineering Patterns

Few-Shot Learning

def few_shot_classification(text: str, categories: List[str]) -> str:
    """
    Classify text using few-shot examples
    """
    prompt = f"""Classify the following text into one of these categories: {', '.join(categories)}

Examples:
Text: "The package arrived quickly and was well packed."
Category: Shipping

Text: "The product quality is poor and broke after one use."
Category: Product Quality

Text: "Customer service was unhelpful and rude."
Category: Customer Service

Now classify:
Text: "{text}"
Category:"""

    response = client.chat.completions.create(
        model="gpt-4-turbo-preview",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3
    )

    return response.choices[0].message.content.strip()

Chain-of-Thought Reasoning

def solve_with_cot(problem: str) -> str:
    """
    Solve problem using Chain-of-Thought prompting
    """
    prompt = f"""Solve this problem step by step. Show your reasoning.

Problem: {problem}

Let's think through this step by step:
1."""

    response = client.chat.completions.create(
        model="gpt-4-turbo-preview",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.7,
        max_tokens=1000
    )

    return response.choices[0].message.content

Production Best Practices and Limitations

Production Checklist

Cost Optimization:

✅ Use smaller models for simple tasks (GPT-3.5 vs GPT-4)
✅ Cache responses for common queries
✅ Implement request batching
✅ Use streaming for long responses
✅ Monitor token usage per endpoint

Safety & Moderation:

✅ Filter toxic content (OpenAI Moderation API)
✅ Implement rate limiting per user
✅ Log all queries for auditing
✅ Add content filters for PII
✅ Use system prompts to define boundaries

Reliability:

✅ Implement retry logic with exponential backoff
✅ Gracefully handle API timeouts
✅ Monitor latency (p50, p95, p99)
✅ A/B test prompts for quality
✅ Validate outputs before showing to users

Known Limitations

Limitation	Impact	Mitigation
Hall ucinations	Models generate plausible but incorrect information	Use RAG, cite sources, add disclaimers
Context Length	Limited to 8K-200K tokens depending on model	Summarize long documents, use sliding windows
Cost	GPT-4: $0.01-0.03 per 1K tokens	Cache responses, use smaller models where possible
Latency	2-10 seconds for complex queries	Stream responses, use async generation
Stale Knowledge	Training data cutoff (GPT-4: April 2023)	Use RAG for current information
Bias	Inherits biases from training data	Test across demographics, use diverse prompts

Security Considerations

# security_checks.py - Content moderation and safety
from openai import OpenAI

def moderate_content(text: str) -> Dict:
    """
    Check content for policy violations using OpenAI Moderation API
    """
    client = OpenAI()

    response = client.moderations.create(input=text)
    result = response.results[0]

    return {
        'flagged': result.flagged,
        'categories': {
            category: score
            for category, score in result.category_scores.items()
            if score > 0.5  # Threshold for flagging
        }
    }

# Example usage
user_input = "Tell me how to hack into a computer"
moderation_result = moderate_content(user_input)

if moderation_result['flagged']:
    print("Content violated policy:", moderation_result['categories'])
    # Block request
else:
    # Process request
    pass

Conclusion and Resources

Large Language Models have evolved from research projects to production systems powering critical applications. Key takeaways:

Transformer Architecture: Self-attention mechanism enables processing long sequences
Modern LLMs: GPT-4, Claude, Llama each have strengths for different use cases
RAG: Grounds LLM responses in external knowledge, reducing hallucinations
Fine-Tuning: LoRA enables efficient adaptation to specific domains
Prompt Engineering: Few-shot learning and chain-of-thought improve outputs

Production deployment requires careful attention to cost, latency, safety, and reliability.

Further Resources:

Attention Is All You Need: https://arxiv.org/abs/1706.03762 (original transformer paper)
Hugging Face Transformers: https://huggingface.co/docs/transformers/
OpenAI API Docs: https://platform.openai.com/docs/
Anthropic Claude Docs: https://docs.anthropic.com/
PEFT Library (LoRA): https://github.com/huggingface/peft
LangChain (RAG framework): https://python.langchain.com/
Prompt Engineering Guide: https://www.promptingguide.ai/