# Examples
This document provides practical examples of using Shimmy in various scenarios.
## Basic Usage Examples
### Simple Text Generation
```bash
# Start Shimmy server
export SHIMMY_BASE_GGUF=/path/to/model.gguf
shimmy serve --bind 127.0.0.1:11435
# Generate text via CLI
shimmy generate --prompt "Write a haiku about programming" --max-tokens 50
# Generate text via API
curl -X POST http://localhost:11435/api/generate \
-H "Content-Type: application/json" \
-d '{
"model": "default",
"prompt": "Write a haiku about programming",
"max_tokens": 50,
"temperature": 0.7
}'
```
### Streaming Response
```bash
# Stream tokens as they're generated
curl -N -X POST http://localhost:11435/api/generate \
-H "Content-Type: application/json" \
-d '{
"model": "default",
"prompt": "Count from 1 to 10:",
"max_tokens": 100,
"stream": true
}'
```
## Code Generation Examples
### Function Documentation
```bash
# Generate documentation for a function
curl -X POST http://localhost:11435/api/generate \
-H "Content-Type: application/json" \
-d '{
"model": "default",
"prompt": "Document this Rust function:\n\nfn calculate_fibonacci(n: u32) -> u64 {\n match n {\n 0 => 0,\n 1 => 1,\n _ => calculate_fibonacci(n - 1) + calculate_fibonacci(n - 2)\n }\n}",
"max_tokens": 200
}'
```
### Code Review
```bash
# Generate code review comments
curl -X POST http://localhost:11435/api/generate \
-H "Content-Type: application/json" \
-d '{
"model": "default",
"prompt": "Review this code for potential issues:\n\n```rust\nfn unsafe_divide(a: i32, b: i32) -> i32 {\n a / b\n}\n```",
"max_tokens": 150
}'
```
## Automation Examples
### Git Commit Message Generation
```bash
#!/bin/bash
# commit_helper.sh
# Get staged changes
diff=$(git diff --cached)
if [ -z "$diff" ]; then
echo "No staged changes found"
exit 1
fi
# Generate commit message
commit_msg=$(curl -s -X POST http://localhost:11435/api/generate \
-H "Content-Type: application/json" \
-d "{
\"model\": \"default\",
\"prompt\": \"Generate a concise git commit message for these changes:\\n\\n$diff\",
\"max_tokens\": 50,
\"temperature\": 0.3
echo "Suggested commit message:"
echo "$commit_msg"
read -p "Use this message? (y/n): " confirm
if [ "$confirm" = "y" ]; then
git commit -m "$commit_msg"
fi
```
### Code Documentation Generator
```python
#!/usr/bin/env python3
import os
import requests
import re
def generate_docs(file_path):
"""Generate documentation for a source file using Shimmy."""
with open(file_path, 'r') as f:
code = f.read()
prompt = f"""Generate comprehensive documentation for this code file:
{code}
Include:
1. Overview of what the file does
2. Main functions and their purposes
3. Key data structures
4. Usage examples
Documentation:"""
response = requests.post('http://localhost:11435/api/generate', json={
'model': 'default',
'prompt': prompt,
'max_tokens': 500,
'temperature': 0.2
})
return response.json()['choices'][0]['text']
# Usage
if __name__ == '__main__':
import sys
if len(sys.argv) != 2:
print("Usage: python3 doc_generator.py <source_file>")
sys.exit(1)
file_path = sys.argv[1]
docs = generate_docs(file_path)
# Save documentation
doc_path = file_path.replace('.rs', '_docs.md').replace('.py', '_docs.md')
with open(doc_path, 'w') as f:
f.write(f"# Documentation for {file_path}\n\n")
f.write(docs)
print(f"Documentation generated: {doc_path}")
```
## WebSocket Examples
### Interactive Chat Client
```javascript
// chat_client.js
const WebSocket = require('ws');
class ShimmyChat {
constructor(url = 'ws://localhost:11435/ws/generate') {
this.ws = new WebSocket(url);
this.setupEventHandlers();
}
setupEventHandlers() {
this.ws.on('open', () => {
console.log('Connected to Shimmy');
});
this.ws.on('message', (data) => {
const message = JSON.parse(data);
if (message.done) {
console.log('\n--- Response complete ---');
} else {
process.stdout.write(message.token);
}
});
this.ws.on('error', (error) => {
console.error('WebSocket error:', error);
});
}
send(prompt, options = {}) {
const message = {
model: 'default',
prompt: prompt,
max_tokens: options.maxTokens || 200,
temperature: options.temperature || 0.7
};
this.ws.send(JSON.stringify(message));
}
close() {
this.ws.close();
}
}
// Usage
const chat = new ShimmyChat();
// Wait for connection
setTimeout(() => {
chat.send("Hello, how can you help me today?");
}, 1000);
```
### Real-time Code Assistance
```html
<!DOCTYPE html>
<html>
<head>
<title>Shimmy Code Assistant</title>
<style>
.container { max-width: 800px; margin: 0 auto; padding: 20px; }
.input-area { width: 100%; height: 200px; margin-bottom: 10px; }
.output-area { width: 100%; height: 300px; border: 1px solid #ccc; padding: 10px; }
button { padding: 10px 20px; margin: 5px; }
</style>
</head>
<body>
<div class="container">
<h1>Shimmy Code Assistant</h1>
<textarea class="input-area" id="codeInput"
placeholder="Paste your code here..."></textarea>
<button onclick="explainCode()">Explain Code</button>
<button onclick="findBugs()">Find Bugs</button>
<button onclick="optimize()">Optimize</button>
<div class="output-area" id="output"></div>
</div>
<script>
let ws = null;
function connectWebSocket() {
ws = new WebSocket('ws://localhost:11435/ws/generate');
ws.onmessage = function(event) {
const data = JSON.parse(event.data);
if (!data.done) {
document.getElementById('output').innerHTML += data.token;
}
};
}
function sendPrompt(prompt) {
if (!ws || ws.readyState !== WebSocket.OPEN) {
connectWebSocket();
setTimeout(() => sendPrompt(prompt), 1000);
return;
}
document.getElementById('output').innerHTML = '';
ws.send(JSON.stringify({
model: 'default',
prompt: prompt,
max_tokens: 300,
temperature: 0.3
}));
}
function explainCode() {
const code = document.getElementById('codeInput').value;
const prompt = `Explain what this code does:\n\n${code}`;
sendPrompt(prompt);
}
function findBugs() {
const code = document.getElementById('codeInput').value;
const prompt = `Find potential bugs in this code:\n\n${code}`;
sendPrompt(prompt);
}
function optimize() {
const code = document.getElementById('codeInput').value;
const prompt = `Suggest optimizations for this code:\n\n${code}`;
sendPrompt(prompt);
}
// Connect on page load
connectWebSocket();
</script>
</body>
</html>
```
## Integration Examples
### Vim Plugin
```vim
" shimmy.vim - Vim plugin for Shimmy integration
function! ShimmyGenerate(prompt)
let l:cmd = "curl -s -X POST http://localhost:11435/api/generate " .
\ "-H 'Content-Type: application/json' " .
\ "-d '{\"model\":\"default\",\"prompt\":\"" . a:prompt . "\",\"max_tokens\":200}'"
let l:response = system(l:cmd)
let l:json = json_decode(l:response)
if has_key(l:json, 'choices') && len(l:json.choices) > 0
return l:json.choices[0].text
else
return "Error: Could not generate response"
endif
endfunction
function! ShimmyExplainSelection()
let l:selected = getline("'<", "'>")
let l:code = join(l:selected, "\n")
let l:prompt = "Explain this code:\n\n" . l:code
let l:explanation = ShimmyGenerate(l:prompt)
" Insert explanation as comments
call append(line("'>"), "")
call append(line("'>") + 1, "\" " . l:explanation)
endfunction
" Commands
command! -range ShimmyExplain call ShimmyExplainSelection()
command! -nargs=1 ShimmyAsk echo ShimmyGenerate(<q-args>)
" Mappings
vnoremap <leader>se :ShimmyExplain<CR>
nnoremap <leader>sa :ShimmyAsk<Space>
```
### GitHub Actions Integration
```yaml
# .github/workflows/ai-review.yml
name: AI Code Review
on:
pull_request:
types: [opened, synchronize]
jobs:
ai-review:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
with:
fetch-depth: 0
- name: Setup Shimmy
run: |
# Download and setup Shimmy
wget https://github.com/user/shimmy/releases/latest/download/shimmy-linux
chmod +x shimmy-linux
export SHIMMY_BASE_GGUF=/models/code-review-model.gguf
./shimmy-linux serve --bind 127.0.0.1:11435 &
sleep 10
- name: Generate Review
run: |
# Get diff
git diff origin/main..HEAD > diff.txt
# Generate review with Shimmy
curl -X POST http://localhost:11435/api/generate \
-H "Content-Type: application/json" \
-d @- << EOF > review.md
{
"model": "default",
"prompt": "Review this code change and provide constructive feedback:\n\n$(cat diff.txt)",
"max_tokens": 1000,
"temperature": 0.3
}
EOF
- name: Post Review
uses: actions/github-script@v6
with:
script: |
const fs = require('fs');
const review = fs.readFileSync('review.md', 'utf8');
github.rest.issues.createComment({
issue_number: context.issue.number,
owner: context.repo.owner,
repo: context.repo.repo,
body: `## AI Code Review\n\n${review}`
});
```
## Performance Examples
### Benchmarking Script
```bash
#!/bin/bash
# benchmark_shimmy.sh
SHIMMY_URL="http://localhost:11435/api/generate"
PROMPTS=(
"Hello world"
"Write a function to calculate fibonacci numbers"
"Explain quantum computing in simple terms"
"Generate a JSON schema for a user profile"
)
echo "Benchmarking Shimmy performance..."
echo "URL: $SHIMMY_URL"
echo "=========================="
total_time=0
total_requests=0
for prompt in "${PROMPTS[@]}"; do
echo "Testing prompt: $prompt"
start_time=$(date +%s.%N)
response=$(curl -s -X POST "$SHIMMY_URL" \
-H "Content-Type: application/json" \
-d "{
\"model\": \"default\",
\"prompt\": \"$prompt\",
\"max_tokens\": 100,
\"temperature\": 0.7
}")
end_time=$(date +%s.%N)
duration=$(echo "$end_time - $start_time" | bc)
tokens=$(echo "$response" | jq -r '.usage.completion_tokens // 0')
echo " Duration: ${duration}s"
echo " Tokens: $tokens"
if [ "$tokens" -gt 0 ]; then
tokens_per_sec=$(echo "scale=2; $tokens / $duration" | bc)
echo " Tokens/sec: $tokens_per_sec"
fi
echo "---"
total_time=$(echo "$total_time + $duration" | bc)
total_requests=$((total_requests + 1))
done
avg_time=$(echo "scale=3; $total_time / $total_requests" | bc)
echo "=========================="
echo "Total requests: $total_requests"
echo "Total time: ${total_time}s"
echo "Average time per request: ${avg_time}s"
```