467 lines
12 KiB
Markdown
467 lines
12 KiB
Markdown
---
|
|
language: en
|
|
license: apache-2.0
|
|
tags:
|
|
- code
|
|
- coding-agent
|
|
- instruction-tuned
|
|
- hermit-code
|
|
- qwen2.5-coder
|
|
- text-generation
|
|
- python
|
|
- javascript
|
|
- rust
|
|
- go
|
|
pipeline_tag: text-generation
|
|
base_model:
|
|
- Qwen/Qwen2.5-Coder-7B-Instruct
|
|
---
|
|
|
|
<div align="center">
|
|
|
|
<!-- Hero Banner -->
|
|
<h1>
|
|
<img src="https://img.shields.io/badge/🐚-Hermit%20Code%207B-2ea44f?style=for-the-badge&logoColor=white" alt="Hermit Code 7B"/>
|
|
</h1>
|
|
|
|
<p><em>The official coding model for the <strong>Hermit AI Agent</strong></em></p>
|
|
|
|
<!-- Animated-style Status Badges -->
|
|
<p>
|
|
<img src="https://img.shields.io/badge/⚡-7.6B%20Parameters-3b82f6?style=flat-square" alt="Parameters"/>
|
|
<img src="https://img.shields.io/badge/📏-128K%20Context-10b981?style=flat-square" alt="Context"/>
|
|
<img src="https://img.shields.io/badge/🔓-Apache%202.0-f59e0b?style=flat-square" alt="License"/>
|
|
<img src="https://img.shields.io/badge/💾-Safetensors%20BF16-f97316?style=flat-square" alt="Format"/>
|
|
<img src="https://img.shields.io/badge/🐍-Python%203.10%2B-3776ab?style=flat-square" alt="Python"/>
|
|
</p>
|
|
|
|
<p>
|
|
<a href="#-quick-start"><img src="https://img.shields.io/badge/🚀%20Quick%20Start-5865F2?style=for-the-badge&logoColor=white" height="28"/></a>
|
|
<a href="#-capabilities"><img src="https://img.shields.io/badge/🎯%20Capabilities-5865F2?style=for-the-badge&logoColor=white" height="28"/></a>
|
|
<a href="#-usage"><img src="https://img.shields.io/badge/💻%20Usage-5865F2?style=for-the-badge&logoColor=white" height="28"/></a>
|
|
<a href="#-benchmarks"><img src="https://img.shields.io/badge/📊%20Benchmarks-5865F2?style=for-the-badge&logoColor=white" height="28"/></a>
|
|
</p>
|
|
|
|
</div>
|
|
|
|
---
|
|
|
|
## 📑 Table of Contents
|
|
|
|
- [Quick Start](#-quick-start)
|
|
- [Capabilities](#-capabilities)
|
|
- [Model Details](#-model-details)
|
|
- [Usage](#-usage)
|
|
- [Transformers](#transformers)
|
|
- [vLLM (Production)](#vllm-recommended-for-production)
|
|
- [Inference API](#inference-api)
|
|
- [Interactive Examples](#-interactive-examples)
|
|
- [Benchmarks](#-benchmarks)
|
|
- [Acknowledgments](#-acknowledgments)
|
|
|
|
---
|
|
|
|
## 🚀 Quick Start
|
|
|
|
Get up and running in **3 lines of code**:
|
|
|
|
```python
|
|
from transformers import pipeline
|
|
|
|
# Initialize the model
|
|
pipe = pipeline("text-generation", model="Soloman2002/hermit-code-7b")
|
|
|
|
# Start coding
|
|
chat = [{"role": "user", "content": "Write a Python function to reverse a linked list"}]
|
|
response = pipe(chat, max_new_tokens=512)
|
|
|
|
print(response[0]["generated_text"][-1]["content"])
|
|
```
|
|
|
|
> 💡 **Tip:** For best results, use `temperature=0.2` and `top_p=0.95` for deterministic code generation.
|
|
|
|
---
|
|
|
|
## 🎯 Capabilities
|
|
|
|
<div align="center">
|
|
|
|
| 💻 **Languages** | 🏗️ **Code Gen** | 📖 **Explain** | 🐛 **Debug** | ⚡ **Refactor** | 🧠 **Context** |
|
|
|:---:|:---:|:---:|:---:|:---:|:---:|
|
|
| Python | Functions | Breakdowns | Bug Finding | Performance | 128K Tokens |
|
|
| JavaScript / TypeScript | Classes | Documentation | Fixing | Cleanup | Multi-file |
|
|
| Go | Scripts | Architecture | Optimization | Restructuring | Projects |
|
|
| Rust | Full Projects | Best Practices | Analysis | Modernization | Understanding |
|
|
| C++ | | | | | |
|
|
| Java | | | | | |
|
|
|
|
</div>
|
|
|
|
### ✨ What Makes Hermit Code Special?
|
|
|
|
- **🌐 Multi-Language Mastery** — Native fluency in 6+ programming languages
|
|
- **📦 Project-Scale Context** — Understand entire codebases with 128K token context
|
|
- **🔍 Debugging Expert** — Identifies bugs, explains why they happen, and fixes them
|
|
- **🎓 Educational** — Explains complex concepts with clear, step-by-step reasoning
|
|
- **⚙️ Production-Ready** — Optimized for both research and deployment via vLLM
|
|
|
|
---
|
|
|
|
## 🧠 Model Details
|
|
|
|
<div align="center">
|
|
|
|
| Property | Specification | Notes |
|
|
|:---|:---|:---|
|
|
| **Base Model** | [Qwen/Qwen2.5-Coder-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-Coder-7B-Instruct) | State-of-the-art code foundation |
|
|
| **Architecture** | Qwen2.5 Dense Transformer | Optimized for code understanding |
|
|
| **Parameters** | 7.61B (6.53B non-embedding) | Efficient size-to-performance ratio |
|
|
| **Layers** | 28 | Deep representation learning |
|
|
| **Attention** | GQA — 28 Q heads, 4 KV heads | Fast inference with grouped queries |
|
|
| **Context Length** | 131,072 tokens | ~100K+ lines of code context |
|
|
| **License** | Apache 2.0 | Commercial use permitted |
|
|
| **Format** | Safetensors (BF16) | Safe, efficient serialization |
|
|
|
|
</div>
|
|
|
|
---
|
|
|
|
## 💻 Usage
|
|
|
|
### Transformers
|
|
|
|
Perfect for **prototyping** and **local development**:
|
|
|
|
```python
|
|
from transformers import AutoModelForCausalLM, AutoTokenizer
|
|
import torch
|
|
|
|
# Load model and tokenizer
|
|
model_id = "Soloman2002/hermit-code-7b"
|
|
model = AutoModelForCausalLM.from_pretrained(
|
|
model_id,
|
|
torch_dtype=torch.bfloat16,
|
|
device_map="auto"
|
|
)
|
|
tokenizer = AutoTokenizer.from_pretrained(model_id)
|
|
|
|
# Prepare chat messages
|
|
messages = [
|
|
{"role": "system", "content": "You are Hermit Code, an expert coding assistant."},
|
|
{"role": "user", "content": "Write a Rust function that checks if a string is a palindrome."}
|
|
]
|
|
|
|
# Apply chat template
|
|
text = tokenizer.apply_chat_template(
|
|
messages,
|
|
tokenize=False,
|
|
add_generation_prompt=True
|
|
)
|
|
|
|
# Generate
|
|
inputs = tokenizer([text], return_tensors="pt").to(model.device)
|
|
outputs = model.generate(
|
|
**inputs,
|
|
max_new_tokens=512,
|
|
temperature=0.2,
|
|
do_sample=True
|
|
)
|
|
|
|
# Decode response
|
|
response = tokenizer.decode(
|
|
outputs[0][inputs.input_ids.shape[1]:],
|
|
skip_special_tokens=True
|
|
)
|
|
print(response)
|
|
```
|
|
|
|
---
|
|
|
|
### vLLM (Recommended for Production)
|
|
|
|
For **high-throughput** serving and API deployment:
|
|
|
|
**1. Install & Launch:**
|
|
```bash
|
|
pip install vllm
|
|
vllm serve "Soloman2002/hermit-code-7b" --dtype bfloat16
|
|
```
|
|
|
|
**2. Query via API:**
|
|
```bash
|
|
curl -X POST "http://localhost:8000/v1/chat/completions" \
|
|
-H "Content-Type: application/json" \
|
|
-d '{
|
|
"model": "Soloman2002/hermit-code-7b",
|
|
"messages": [
|
|
{"role": "system", "content": "You are Hermit Code, a coding assistant."},
|
|
{"role": "user", "content": "Explain closures in JavaScript with examples."}
|
|
],
|
|
"temperature": 0.2,
|
|
"max_tokens": 512
|
|
}'
|
|
```
|
|
|
|
> 🚀 **vLLM Benefits:** Continuous batching, PagedAttention, and 10-20x throughput improvement over standard Transformers.
|
|
|
|
---
|
|
|
|
### Inference API
|
|
|
|
Use **Hugging Face's hosted infrastructure** for instant access:
|
|
|
|
```python
|
|
from huggingface_hub import InferenceClient
|
|
|
|
client = InferenceClient(token="hf_YOUR_TOKEN")
|
|
|
|
response = client.chat_completion(
|
|
model="Soloman2002/hermit-code-7b",
|
|
messages=[
|
|
{"role": "user", "content": "Write a Go function to merge two sorted arrays"}
|
|
],
|
|
max_tokens=512,
|
|
temperature=0.2,
|
|
stream=False
|
|
)
|
|
|
|
print(response.choices[0].message.content)
|
|
```
|
|
|
|
---
|
|
|
|
## 🎨 Interactive Examples
|
|
|
|
Click any language below to expand and see Hermit Code in action:
|
|
|
|
<details>
|
|
<summary><b>🐍 Python</b> — Quick Sort Implementation</summary>
|
|
|
|
```python
|
|
def quick_sort(arr: list[int]) -> list[int]:
|
|
"""
|
|
Sorts an array using the quicksort algorithm.
|
|
Time Complexity: O(n log n) average, O(n²) worst case
|
|
Space Complexity: O(log n) due to recursion
|
|
"""
|
|
if len(arr) <= 1:
|
|
return arr
|
|
|
|
pivot = arr[len(arr) // 2]
|
|
left = [x for x in arr if x < pivot]
|
|
middle = [x for x in arr if x == pivot]
|
|
right = [x for x in arr if x > pivot]
|
|
|
|
return quick_sort(left) + middle + quick_sort(right)
|
|
|
|
|
|
# Example usage
|
|
if __name__ == "__main__":
|
|
data = [3, 6, 8, 10, 1, 2, 1]
|
|
print(f"Original: {data}")
|
|
print(f"Sorted: {quick_sort(data)}")
|
|
```
|
|
|
|
**Key Features Demonstrated:**
|
|
- ✅ Type hints for better code clarity
|
|
- ✅ Docstrings with complexity analysis
|
|
- ✅ Recursive divide-and-conquer approach
|
|
- ✅ Idiomatic Python list comprehensions
|
|
|
|
</details>
|
|
|
|
<details>
|
|
<summary><b>🦀 Rust</b> — Palindrome Checker</summary>
|
|
|
|
```rust
|
|
/// Checks if a string is a palindrome, ignoring non-alphanumeric characters
|
|
/// and case differences.
|
|
///
|
|
/// # Examples
|
|
/// ```
|
|
/// assert!(is_palindrome("A man, a plan, a canal: Panama"));
|
|
/// assert!(!is_palindrome("Hello, World!"));
|
|
/// ```
|
|
fn is_palindrome(s: &str) -> bool {
|
|
let chars: Vec<char> = s
|
|
.chars()
|
|
.filter(|c| c.is_alphanumeric())
|
|
.map(|c| c.to_ascii_lowercase())
|
|
.collect();
|
|
|
|
let len = chars.len();
|
|
for i in 0..len / 2 {
|
|
if chars[i] != chars[len - 1 - i] {
|
|
return false;
|
|
}
|
|
}
|
|
true
|
|
}
|
|
|
|
fn main() {
|
|
let test_cases = vec![
|
|
"racecar",
|
|
"A man, a plan, a canal: Panama",
|
|
"Hello, World!",
|
|
];
|
|
|
|
for case in test_cases {
|
|
println!("'{}' -> {}", case, is_palindrome(case));
|
|
}
|
|
}
|
|
```
|
|
|
|
**Key Features Demonstrated:**
|
|
- ✅ Memory-safe string processing
|
|
- ✅ Functional iterator chains
|
|
- ✅ Comprehensive documentation
|
|
- ✅ Efficient two-pointer comparison
|
|
|
|
</details>
|
|
|
|
<details>
|
|
<summary><b>🐹 Go</b> — Merge Sorted Arrays</summary>
|
|
|
|
```go
|
|
package main
|
|
|
|
import "fmt"
|
|
|
|
// mergeSorted combines two sorted integer slices into a single sorted slice.
|
|
// It runs in O(n + m) time where n and m are the lengths of the inputs.
|
|
func mergeSorted(a, b []int) []int {
|
|
result := make([]int, 0, len(a)+len(b))
|
|
i, j := 0, 0
|
|
|
|
// Merge while both arrays have elements
|
|
for i < len(a) && j < len(b) {
|
|
if a[i] < b[j] {
|
|
result = append(result, a[i])
|
|
i++
|
|
} else {
|
|
result = append(result, b[j])
|
|
j++
|
|
}
|
|
}
|
|
|
|
// Append remaining elements
|
|
result = append(result, a[i:]...)
|
|
result = append(result, b[j:]...)
|
|
|
|
return result
|
|
}
|
|
|
|
func main() {
|
|
a := []int{1, 3, 5, 7}
|
|
b := []int{2, 4, 6, 8}
|
|
|
|
merged := mergeSorted(a, b)
|
|
fmt.Printf("Merged: %v\n", merged) // [1 2 3 4 5 6 7 8]
|
|
}
|
|
```
|
|
|
|
**Key Features Demonstrated:**
|
|
- ✅ Pre-allocated slices for zero-allocation growth
|
|
- ✅ Two-pointer technique for optimal performance
|
|
- ✅ Idiomatic Go error-free design
|
|
- ✅ Clean, readable control flow
|
|
|
|
</details>
|
|
|
|
<details>
|
|
<summary><b>⚡ JavaScript</b> — Closure Example</summary>
|
|
|
|
```javascript
|
|
/**
|
|
* Creates a counter with private state using closures.
|
|
* Demonstrates lexical scoping and data encapsulation.
|
|
*/
|
|
function createCounter(initialValue = 0) {
|
|
let count = initialValue; // Private variable
|
|
|
|
return {
|
|
increment() {
|
|
count += 1;
|
|
return count;
|
|
},
|
|
decrement() {
|
|
count -= 1;
|
|
return count;
|
|
},
|
|
getValue() {
|
|
return count;
|
|
},
|
|
reset() {
|
|
count = initialValue;
|
|
return count;
|
|
}
|
|
};
|
|
}
|
|
|
|
// Usage
|
|
const counter = createCounter(10);
|
|
console.log(counter.increment()); // 11
|
|
console.log(counter.increment()); // 12
|
|
console.log(counter.getValue()); // 12
|
|
console.log(counter.reset()); // 10
|
|
```
|
|
|
|
**Key Features Demonstrated:**
|
|
- ✅ True private state via closures
|
|
- ✅ Clean object interface
|
|
- ✅ ES6 method shorthand syntax
|
|
- ✅ Default parameter values
|
|
|
|
</details>
|
|
|
|
---
|
|
|
|
## 📊 Benchmarks
|
|
|
|
<div align="center">
|
|
|
|
| Benchmark | Score | Status | Comparison to Base |
|
|
|:---|:---:|:---:|:---|
|
|
| **HumanEval (Python)** | *TBD* | 🔄 Pending | vs Qwen2.5-Coder-7B |
|
|
| **HumanEval (Multi-Lang)** | *TBD* | 🔄 Pending | vs Qwen2.5-Coder-7B |
|
|
| **MBPP (Python)** | *TBD* | 🔄 Pending | vs Qwen2.5-Coder-7B |
|
|
| **DS-1000 (Data Science)** | *TBD* | 🔄 Pending | vs Qwen2.5-Coder-7B |
|
|
|
|
</div>
|
|
|
|
> 📈 **Coming Soon:** Comprehensive evaluation results based on the Qwen2.5-Coder-7B-Instruct baseline with additional fine-tuning for agentic coding workflows.
|
|
|
|
---
|
|
|
|
## 🤝 Acknowledgments
|
|
|
|
<div align="center">
|
|
|
|
| Contribution | Team / Resource | Link |
|
|
|:---|:---|:---|
|
|
| **🏗️ Base Model** | Qwen Team | [Qwen2.5-Coder-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-Coder-7B-Instruct) |
|
|
| **🤖 Hermit AI Agent** | Hermit Team | [GitHub: Soloman2002](https://github.com/Soloman2002) |
|
|
| **📦 Infrastructure** | Hugging Face | [Transformers](https://github.com/huggingface/transformers) & [vLLM](https://github.com/vllm-project/vllm) |
|
|
|
|
</div>
|
|
|
|
---
|
|
|
|
<div align="center">
|
|
|
|
## 🌟 Star Us on GitHub!
|
|
|
|
If you find Hermit Code useful, please consider starring the repository and sharing with your network.
|
|
|
|
<p>
|
|
<a href="https://github.com/Soloman2002/hermit-code-7b">
|
|
<img src="https://img.shields.io/badge/⭐-Star%20on%20GitHub-181717?style=for-the-badge&logo=github" alt="Star on GitHub"/>
|
|
</a>
|
|
<a href="https://huggingface.co/Soloman2002/hermit-code-7b">
|
|
<img src="https://img.shields.io/badge/🤗-Follow%20on%20HF-FFD21E?style=for-the-badge" alt="Follow on Hugging Face"/>
|
|
</a>
|
|
</p>
|
|
|
|
<sub>Built with ❤️ for the coding community by the Hermit Team</sub>
|
|
|
|
</div> |