Upload v0.1.0/README.md with huggingface_hub

v0.1.0/README.md

@@ -0,0 +1,645 @@
+# Local-Llama-Inference
+
+![Version](https://img.shields.io/badge/version-0.1.0-blue)
+![Python](https://img.shields.io/badge/python-3.8%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+**A Production-Ready Python SDK for GPU-Accelerated LLM Inference**
+
+Local-Llama-Inference is a comprehensive Python SDK that integrates **llama.cpp** and **NVIDIA NCCL** to enable high-performance inference of GGUF-quantized Large Language Models (LLMs) on single and multiple NVIDIA GPUs.
+
+---
+
+## 🎯 Features
+
+### 🚀 Core Capabilities
+- **Single GPU Inference** - Automatic memory optimization and layer offloading
+- **Multi-GPU Support** - Tensor parallelism with automatic split suggestions
+- **30+ REST API Endpoints** - Full llama.cpp endpoint coverage
+- **OpenAI-Compatible API** - Drop-in compatible `/v1/chat/completions` endpoint
+- **Streaming Responses** - Token-by-token streaming via Python generators
+- **Production-Ready** - Error handling, process management, health checks
+
+### 🔌 API Support
+```python
+# Chat & Completions
+client.chat()              # Chat completion (non-streaming)
+client.stream_chat()       # Chat with token streaming
+client.complete()          # Text completion
+client.stream_complete()   # Streaming completion
+
+# Embeddings & Reranking
+client.embed()            # Generate embeddings
+client.rerank()           # Cross-encoder reranking
+
+# Token Utilities
+client.tokenize()         # Text to tokens
+client.detokenize()       # Tokens to text
+client.apply_template()   # Apply chat template
+
+# Advanced Features
+client.infill()           # Code infilling
+client.set_lora_adapters() # LoRA support
+client.save_slot()        # Slot management
+client.restore_slot()     # Restore saved state
+
+# Server Management
+client.health()           # Health check
+client.get_props()        # Get server properties
+client.get_metrics()      # Performance metrics
+```
+
+### 🎮 GPU Utilities
+```python
+from local_llama_inference import detect_gpus, suggest_tensor_split, check_cuda_version
+
+# Detect available GPUs
+gpus = detect_gpus()
+
+# Get automatic tensor split for multi-GPU
+tensor_split = suggest_tensor_split(gpus)
+
+# Check CUDA version
+cuda_version = check_cuda_version()
+```
+
+### 📊 NCCL Collective Operations
+```python
+from local_llama_inference._bindings.nccl_binding import NCCLBinding
+
+# Direct access to NCCL primitives
+nccl = NCCLBinding('/path/to/libnccl.so.2')
+nccl.all_reduce(sendbuff, recvbuff, ncclFloat32, ncclSum, comm)
+nccl.broadcast(buffer, ncclFloat32, root, comm)
+nccl.all_gather(sendbuff, recvbuff, ncclFloat32, comm)
+```
+
+---
+
+## 📋 System Requirements
+
+### Minimum
+- **GPU**: NVIDIA compute capability 5.0+ (sm_50)
+  - Tesla K80, K40 | GeForce GTX 750 Ti
+- **VRAM**: 2GB+ per GPU
+- **Python**: 3.8+
+- **OS**: Linux x86_64
+- **RAM**: 8GB+ system memory
+
+### Recommended
+- **GPU**: RTX 2060 or newer (sm_75+)
+- **VRAM**: 4GB+ per GPU
+- **RAM**: 16GB+ system memory
+- **CUDA**: Any version 11.5+ (runtime included)
+
+### Supported GPUs
+✅ Kepler (sm_50) - Tesla K80, K40, GTX 750 Ti
+✅ Maxwell (sm_61) - GTX 750, GTX 950, GTX 1050
+✅ Pascal (sm_61) - GTX 1060, GTX 1080
+✅ Volta (sm_70) - Tesla V100
+✅ Turing (sm_75) - RTX 2060, RTX 2080
+✅ Ampere (sm_80) - RTX 3060, RTX 3090
+✅ Ada (sm_86) - RTX 4080, RTX 6000
+✅ Hopper (sm_89) - H100, H200
+
+---
+
+## ⚡ Quick Start (5 Minutes)
+
+### 1. Installation
+
+#### Option A: From Release Package (Recommended)
+```bash
+# Download from GitHub Releases
+# https://github.com/Local-Llama-Inference/Local-Llama-Inference/releases/tag/v0.1.0
+
+tar -xzf local-llama-inference-complete-v0.1.0.tar.gz
+cd local-llama-inference-v0.1.0
+pip install -e ./python
+```
+
+#### Option B: From Source (Developer)
+```bash
+git clone https://github.com/Local-Llama-Inference/Local-Llama-Inference.git
+cd Local-Llama-Inference/local-llama-inference
+pip install -e .
+```
+
+### 2. Verify Installation
+```bash
+python -c "from local_llama_inference import LlamaServer, detect_gpus; print('✅ SDK Ready'); print(detect_gpus())"
+```
+
+### 3. Download a Model
+```bash
+# Download Mistral 7B Q4 (quantized, ~4GB)
+wget https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.1-GGUF/resolve/main/Mistral-7B-Instruct-v0.1.Q4_K_M.gguf
+
+# Or find more models at: https://huggingface.co/models?search=gguf
+```
+
+### 4. Run Your First Inference
+```python
+from local_llama_inference import LlamaServer, LlamaClient
+
+# Start the server
+server = LlamaServer(
+    model_path="./Mistral-7B-Instruct-v0.1.Q4_K_M.gguf",
+    n_gpu_layers=33,  # Offload all layers to GPU
+    n_ctx=2048,       # Context window
+    host="127.0.0.1",
+    port=8000
+)
+
+print("Starting server...")
+server.start()
+server.wait_ready(timeout=60)
+print("✅ Server ready!")
+
+# Create client and send request
+client = LlamaClient(base_url="http://127.0.0.1:8000")
+
+response = client.chat_completion(
+    messages=[
+        {"role": "system", "content": "You are a helpful AI assistant."},
+        {"role": "user", "content": "What is machine learning?"}
+    ],
+    temperature=0.7,
+    max_tokens=256
+)
+
+print("Assistant:", response.choices[0].message.content)
+
+# Cleanup
+server.stop()
+```
+
+---
+
+## 📚 Getting Started Tutorials
+
+### Basic Chat Example
+```python
+from local_llama_inference import LlamaServer, LlamaClient
+
+# Configure and start server
+server = LlamaServer(
+    model_path="model.gguf",
+    n_gpu_layers=33,      # Use GPU
+    main_gpu=0,           # Primary GPU
+    n_ctx=2048,           # Context size
+    n_batch=512,          # Batch size
+)
+server.start()
+server.wait_ready()
+
+# Simple chat
+client = LlamaClient()
+response = client.chat_completion(
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+print(response.choices[0].message.content)
+
+# Multi-turn conversation
+messages = [
+    {"role": "system", "content": "You are a helpful assistant."},
+    {"role": "user", "content": "What is Python?"},
+]
+
+response = client.chat_completion(messages=messages)
+print("Assistant:", response.choices[0].message.content)
+
+messages.append({"role": "assistant", "content": response.choices[0].message.content})
+messages.append({"role": "user", "content": "How is it used in AI?"})
+
+response = client.chat_completion(messages=messages)
+print("Assistant:", response.choices[0].message.content)
+
+server.stop()
+```
+
+### Streaming Responses
+```python
+from local_llama_inference import LlamaServer, LlamaClient
+
+server = LlamaServer(model_path="model.gguf", n_gpu_layers=33)
+server.start()
+server.wait_ready()
+
+client = LlamaClient()
+
+# Stream tokens in real-time
+for token in client.stream_chat(
+    messages=[{"role": "user", "content": "Write a poem about AI"}]
+):
+    print(token.choices[0].delta.content, end="", flush=True)
+print()
+
+server.stop()
+```
+
+### Multi-GPU Inference
+```python
+from local_llama_inference import (
+    LlamaServer, LlamaClient, detect_gpus, suggest_tensor_split
+)
+
+# Detect GPUs
+gpus = detect_gpus()
+print(f"Found {len(gpus)} GPU(s)")
+
+# Get suggested tensor split
+tensor_split = suggest_tensor_split(gpus)
+print(f"Suggested tensor split: {tensor_split}")
+
+# Start with multi-GPU
+server = LlamaServer(
+    model_path="model.gguf",
+    n_gpu_layers=33,
+    tensor_split=tensor_split,  # Distribute layers across GPUs
+)
+server.start()
+server.wait_ready()
+
+# Use normally
+client = LlamaClient()
+response = client.chat_completion(
+    messages=[{"role": "user", "content": "Process this on multiple GPUs!"}]
+)
+print(response.choices[0].message.content)
+
+server.stop()
+```
+
+### Embeddings
+```python
+from local_llama_inference import LlamaServer, LlamaClient
+
+server = LlamaServer(model_path="embedding-model.gguf", n_gpu_layers=33)
+server.start()
+server.wait_ready()
+
+client = LlamaClient()
+
+# Single embedding
+embedding = client.embed(input="What is machine learning?")
+print(f"Embedding dimension: {len(embedding.data[0].embedding)}")
+
+# Batch embeddings
+embeddings = client.embed(
+    input=[
+        "Machine learning is a subset of AI",
+        "Deep learning uses neural networks",
+        "LLMs are large language models"
+    ]
+)
+print(f"Generated {len(embeddings.data)} embeddings")
+
+server.stop()
+```
+
+### Advanced: NCCL Operations
+```python
+from local_llama_inference._bindings.nccl_binding import NCCLBinding, NCCLDataType, NCCLRedOp
+import numpy as np
+
+# Load NCCL
+nccl = NCCLBinding('/path/to/libnccl.so.2')
+
+# AllReduce operation
+sendbuff = np.array([1.0, 2.0, 3.0], dtype=np.float32)
+recvbuff = np.zeros_like(sendbuff)
+
+# This would require NCCL communicator setup
+# nccl.all_reduce(sendbuff.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+#                 recvbuff.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+#                 len(sendbuff), NCCLDataType.FLOAT32, NCCLRedOp.SUM, comm)
+```
+
+---
+
+## 🔧 Configuration
+
+### Server Configuration
+```python
+from local_llama_inference import ServerConfig, SamplingConfig
+
+# Create configuration
+config = ServerConfig(
+    # Model
+    model_path="./model.gguf",
+
+    # Server
+    host="127.0.0.1",
+    port=8000,
+    api_key=None,  # Optional API key
+
+    # GPU settings
+    n_gpu_layers=33,           # Layers to offload to GPU
+    tensor_split=[0.5, 0.5],   # Multi-GPU distribution
+    main_gpu=0,                # Primary GPU
+
+    # Context
+    n_ctx=2048,                # Context window size
+    n_batch=512,               # Batch size
+    n_ubatch=512,              # Micro-batch size
+
+    # Performance
+    flash_attn=True,           # Use Flash Attention v2
+    numa=False,                # NUMA optimization
+
+    # Advanced
+    use_mmap=True,             # Memory mapped I/O
+    use_mlock=False,           # Lock memory
+    embedding_only=False,      # Embedding mode
+)
+
+# Generate CLI arguments
+args = config.to_args()
+
+# Create server
+server = LlamaServer(config)
+```
+
+### Sampling Configuration
+```python
+from local_llama_inference import SamplingConfig
+
+sampling_config = SamplingConfig(
+    temperature=0.7,           # Higher = more random
+    top_k=40,                  # Nucleus sampling
+    top_p=0.9,                 # Cumulative probability
+    min_p=0.05,                # Minimum probability
+    repeat_penalty=1.1,        # Penalize repetition
+    mirostat=0,                # Mirostat sampling (0=off)
+    seed=42,                   # Random seed
+    grammar=None,              # Grammar constraints
+    json_schema=None,          # JSON schema
+)
+
+# Use in request
+response = client.chat_completion(
+    messages=[{"role": "user", "content": "Hello"}],
+    temperature=sampling_config.temperature,
+    top_k=sampling_config.top_k,
+    top_p=sampling_config.top_p,
+)
+```
+
+---
+
+## 📖 API Reference
+
+### `LlamaServer` - Process Management
+```python
+server = LlamaServer(config, binary_path=None)
+
+# Methods
+server.start(wait_ready=False, timeout=60)     # Start server
+server.stop()                                   # Stop server
+server.restart()                                # Restart server
+server.is_running()                             # Check status
+server.wait_ready(timeout=60)                   # Wait for /health
+```
+
+### `LlamaClient` - HTTP REST Client
+```python
+client = LlamaClient(base_url="http://127.0.0.1:8000", api_key=None)
+
+# Chat & Completions
+client.chat_completion(messages, model=None, **kwargs)
+client.stream_chat(messages, model=None, **kwargs)
+client.complete(prompt, model=None, **kwargs)
+client.stream_complete(prompt, model=None, **kwargs)
+
+# Embeddings
+client.embed(input, model=None)
+client.rerank(model, query, documents)
+
+# Tokens
+client.tokenize(prompt, add_special=True)
+client.detokenize(tokens)
+client.apply_template(messages, add_generation_prompt=True)
+
+# Server Info
+client.health()                    # GET /health
+client.get_props()                 # GET /props
+client.set_props(props)            # POST /props
+client.get_metrics()               # GET /metrics
+client.get_models()                # GET /models
+client.get_slots()                 # GET /slots
+```
+
+### `detect_gpus()` - GPU Detection
+```python
+gpus = detect_gpus()
+# Returns: List[GPUInfo]
+# Each GPUInfo has: index, name, uuid, compute_capability, total_memory_mb, free_memory_mb
+
+for gpu in gpus:
+    print(f"GPU {gpu.index}: {gpu.name}")
+    print(f"  Compute Capability: {gpu.compute_capability}")
+    print(f"  VRAM: {gpu.total_memory_mb} MB ({gpu.free_memory_mb} MB free)")
+    print(f"  Supports Flash Attention: {gpu.supports_flash_attn()}")
+```
+
+### `suggest_tensor_split()` - Auto Multi-GPU
+```python
+tensor_split = suggest_tensor_split(gpus)
+# Automatically calculates optimal layer distribution
+# Returns: List[float] summing to 1.0
+```
+
+---
+
+## 🛠️ Troubleshooting
+
+### "CUDA out of memory"
+```python
+# Solution 1: Reduce GPU layers
+server = LlamaServer(model_path="model.gguf", n_gpu_layers=15)
+
+# Solution 2: Use smaller quantization
+# Download Q2 or Q3 instead of Q5/Q6
+
+# Solution 3: Reduce batch size
+server = LlamaServer(model_path="model.gguf", n_batch=256)
+```
+
+### "GPU not found"
+```bash
+# Check NVIDIA driver
+nvidia-smi
+
+# Verify NVIDIA driver is installed
+# https://www.nvidia.com/Download/driverDetails.aspx
+
+# Check compute capability
+python -c "from local_llama_inference import detect_gpus; print(detect_gpus())"
+```
+
+### "libcudart.so.12 not found"
+```bash
+# The complete package includes CUDA runtime
+
+# Or install NVIDIA drivers:
+sudo apt update
+sudo apt install nvidia-driver-XXX  # Replace XXX with version
+sudo reboot
+```
+
+### "Server startup timeout"
+```python
+# Increase timeout
+server.wait_ready(timeout=120)  # Default is 60 seconds
+
+# Or check server logs for errors
+server.start(wait_ready=False)
+time.sleep(5)
+# Check console for error messages
+```
+
+### Slow Inference
+```python
+# Increase GPU offloading
+n_gpu_layers=33  # Offload all layers
+
+# Check GPU utilization
+nvidia-smi -l 1  # Refresh every second
+
+# Use larger models with better quantization (Q5, Q6 instead of Q2)
+# Reduce context size if not needed
+```
+
+---
+
+## 🔗 Key Files & Directories
+
+```
+local-llama-inference/
+├── src/local_llama_inference/        # Python SDK source
+│   ├── __init__.py                   # Public API
+│   ├── server.py                     # LlamaServer class
+│   ├── client.py                     # LlamaClient REST wrapper
+│   ├── config.py                     # Configuration classes
+│   ├── gpu.py                        # GPU utilities
+│   ├── exceptions.py                 # Custom exceptions
+│   ├── _bindings/
+│   │   ├── llama_binding.py          # libllama.so ctypes wrapper
+│   │   └── nccl_binding.py           # libnccl.so.2 ctypes wrapper
+│   └── _bootstrap/
+│       ├── finder.py                 # Binary locator
+│       └── extractor.py              # Bundle extractor
+├── examples/                          # Tutorial scripts
+│   ├── single_gpu_chat.py
+│   ���── multi_gpu_tensor_split.py
+│   ├── streaming_chat.py
+│   ├── embeddings_example.py
+│   └── nccl_bindings_example.py
+├── tests/                             # Unit tests
+├── pyproject.toml                    # Package metadata
+├── README.md                         # This file
+├── LICENSE                           # MIT License
+└── releases/v0.1.0/                 # Release artifacts
+    ├── local-llama-inference-complete-v0.1.0.tar.gz
+    ├── local-llama-inference-sdk-v0.1.0.tar.gz
+    └── CHECKSUMS.txt
+```
+
+---
+
+## 📦 Dependencies
+
+### Required
+- **httpx** >= 0.24.0 - Async HTTP client for REST API
+- **pydantic** >= 2.0 - Data validation and settings management
+
+### Optional (Development)
+- **pytest** >= 7.0 - Unit testing
+- **pytest-asyncio** >= 0.21.0 - Async test support
+
+### System
+- **NVIDIA CUDA** - Any version 11.5+ (runtime included in package)
+- **NVIDIA Drivers** - Required, any recent version
+
+---
+
+## 🚀 Performance Tips
+
+1. **Use Flash Attention** - Set `flash_attn=True` for 2-3x speedup
+2. **Increase Context** - Larger `n_ctx` = slower but better context
+3. **Batch Size** - `n_batch=512` good for most cases
+4. **GPU Layers** - Higher `n_gpu_layers` = faster but more VRAM
+5. **Quantization** - Q4 = 4GB, Q5 = 5GB, Q6 = 6GB typical sizes
+6. **Multi-GPU** - Use `tensor_split` to distribute across GPUs
+7. **Keep Alive** - Reuse server instance instead of restart/start cycles
+
+---
+
+## 🔐 Security
+
+- **API Keys** - Optional API key support via `ServerConfig.api_key`
+- **Local Only** - Bind to `127.0.0.1` for local development
+- **Production** - Consider authentication/TLS for production deployments
+- **Model Files** - Keep GGUF files private, don't share URLs publicly
+
+---
+
+## 📄 License
+
+MIT License - See `LICENSE` file for details
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! Please:
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit changes (`git commit -m 'Add amazing feature'`)
+4. Push to branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+---
+
+## 📞 Support & Resources
+
+- **GitHub Issues**: [Report bugs or request features](https://github.com/Local-Llama-Inference/Local-Llama-Inference/issues)
+- **GitHub Discussions**: [Ask questions and share ideas](https://github.com/Local-Llama-Inference/Local-Llama-Inference/discussions)
+- **Releases**: [Download packages](https://github.com/Local-Llama-Inference/Local-Llama-Inference/releases)
+
+### Related Projects
+- **llama.cpp** - Core inference engine: https://github.com/ggml-org/llama.cpp
+- **NCCL** - GPU collective communication: https://github.com/NVIDIA/nccl
+- **Hugging Face GGUF Models** - https://huggingface.co/models?search=gguf
+
+---
+
+## 📊 Project Status
+
+- **Version**: 0.1.0 (Beta)
+- **Status**: Production Ready
+- **Last Updated**: February 24, 2026
+- **Python Support**: 3.8 - 3.12
+- **GPU Support**: NVIDIA sm_50 and newer
+
+---
+
+## 🎓 Learning Resources
+
+### Official Documentation
+- See `00-START-HERE.md` in release package
+- See `RELEASE_NOTES_v0.1.0.md` for detailed feature list
+- Check `examples/` directory for code samples
+
+### External Resources
+- **llama.cpp Documentation**: https://github.com/ggml-org/llama.cpp/tree/master/docs
+- **GGUF Format**: https://github.com/ggml-org/gguf
+- **NCCL Documentation**: https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/
+
+---
+
+**Built with ❤️ for the open-source ML community**
+
+⭐ If you find this project useful, please consider starring the repository!