Instructions to use my-ai-stack/Stack-2-9-finetuned with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use my-ai-stack/Stack-2-9-finetuned with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="my-ai-stack/Stack-2-9-finetuned")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("my-ai-stack/Stack-2-9-finetuned")
model = AutoModelForCausalLM.from_pretrained("my-ai-stack/Stack-2-9-finetuned")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use my-ai-stack/Stack-2-9-finetuned with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "my-ai-stack/Stack-2-9-finetuned"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "my-ai-stack/Stack-2-9-finetuned",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/my-ai-stack/Stack-2-9-finetuned

SGLang

How to use my-ai-stack/Stack-2-9-finetuned with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "my-ai-stack/Stack-2-9-finetuned" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "my-ai-stack/Stack-2-9-finetuned",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "my-ai-stack/Stack-2-9-finetuned" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "my-ai-stack/Stack-2-9-finetuned",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use my-ai-stack/Stack-2-9-finetuned with Docker Model Runner:
```
docker model run hf.co/my-ai-stack/Stack-2-9-finetuned
```

Stack-2-9-finetuned / stack /docs /archive /IMPLEMENTATION_SUMMARY.md

walidsobhie-code

refactor: Squeeze folders further - cleaner structure

65888d5 2 months ago

preview code

raw

history blame

6.93 kB

Stack 2.9 CLI & Agent Interface - Implementation Summary

✅ Completed Build

I've successfully created a complete CLI and agent interface for Stack 2.9 with 38 built-in tools. All files are located in /Users/walidsobhi/.openclaw/workspace/stack-2.9/.

📁 Created Files

Core Package: `stack-2.9/stack_cli/`

__init__.py - Package initialization
cli.py - Main CLI entry point with 4 modes (interactive chat, command, voice, tool)
agent.py - Core agent with query understanding, tool selection, response generation, self-reflection
tools.py - 37+ built-in tools across 6 categories
context.py - Context management, project scanning, session & long-term memory
pyproject.toml - Package configuration for stack-cli

Entry & Support:

stack.py - Main entry script for running the CLI
STACK_CLI_README.md - Comprehensive documentation
demo_stack.py - Demo script showcasing capabilities
test_imports.py - Import and basic functionality test

Updated:

stack-2.9/requirements.txt - Dependencies note (stack-cli listed)
stack-2.9/pyproject.toml - Restored original devpilot configuration

🔧 38 Built-in Tools

1. File Operations (8 tools)

read - Read file contents with offset/limit
write - Write content to file (create or overwrite)
edit - Edit file using exact text replacement
search - Recursively search for files by pattern
grep - Search for patterns in files with context
copy - Copy files or directories
move - Move or rename files/directories
delete - Delete files/directories (with safety check)

2. Git Operations (7 tools)

git_status - Get git status
git_commit - Create git commit
git_push - Push to remote
git_pull - Pull from remote
git_branch - List, create, delete branches
git_log - View commit history
git_diff - Show git diff

3. Code Execution (7 tools)

run - Run shell commands with timeout
test - Run tests using pytest
lint - Lint code (ruff/pylint/mypy)
format - Format code (ruff/black)
typecheck - Type checking with mypy
server - Start development server (background option)
install - Install dependencies (pip/poetry/npm)

4. Web Tools (5 tools)

web_search - Search the web (brave-search)
fetch - Fetch and extract URL content
download - Download files from URL
check_url - Check URL accessibility
screenshot - Take webpage screenshot (puppeteer)

5. Memory & Context (5 tools)

memory_recall - Search long-term memory (MEMORY.md)
memory_save - Save to memory
memory_list - List memory entries
context_load - Load AGENTS.md, SOUL.md, TOOLS.md
project_scan - Scan project structure

6. Task Planning (6 tools)

create_task - Create a new task
list_tasks - List tasks with filters
update_task - Update task status
delete_task - Delete a task
create_plan - Create execution plan
execute_plan - Execute plan steps

🎯 4 Operation Modes

1. Interactive Chat Mode

python stack.py
# or
python -m stack_cli.cli

Features:

Natural language conversation
Auto-tool selection
Self-reflection
Chat history
Commands: /tools, /schema, /context, /history, /clear, /voice, /exit

2. Command Mode

python stack.py -c "read README.md"
python stack.py -c "git status"

Executes a single query and returns result.

3. Tool Mode

python stack.py -t project_scan memory_list

Executes specific tools directly.

4. Voice Mode

# Install voice dependencies first:
pip install SpeechRecognition pyttsx3 pyaudio

python stack.py -v

Voice input/output (speech recognition + TTS).

🧠 Agent Capabilities

Query Understanding

Pattern matching for 10+ intents
File path extraction
Confidence scoring

Tool Selection

Maps intents to appropriate tools
Parameter extraction from queries
Fallback to general tools

Response Generation

Formats tool results naturally
Error handling and user-friendly messages
Context injection

Self-Reflection Loop

Evaluates success of tool calls
Checks confidence thresholds
Suggests clarifications when needed
Iteration for improvement

📊 Architecture

stack-2.9/
├── stack_cli/              # Main package
│   ├── __init__.py
│   ├── cli.py             # CLI entry (cmd.Cmd based)
│   ├── agent.py           # StackAgent class
│   │   ├── QueryUnderstanding
│   │   ├── ToolSelector
│   │   ├── ResponseGenerator
│   │   └── SelfReflection
│   ├── tools.py           # 38 tool functions + registry
│   └── context.py         # ContextManager, SessionMemory, ProjectContext
├── stack.py                # Entry point script
├── demo_stack.py           # Demo script
├── test_imports.py         # Import test
├── STACK_CLI_README.md     # Full documentation
└── stack_cli/pyproject.toml # Package config

🚀 Quick Start

Install:

cd /Users/walidsobhi/.openclaw/workspace/stack-2.9
pip install -e stack_cli/

Run Demo:

python demo_stack.py

Interactive Chat:

python stack.py

Single Command:

python stack.py -c "list my tasks"

Use as Library:

from stack_cli import create_agent

agent = create_agent()
response = agent.process("read README.md")
print(response.content)

💡 Example Queries

"read main.py"
"git status"
"run pytest"
"search for *.py files"
"create task: implement login"
"remember that the API endpoint is /api/v1"
"scan project structure"
"web search: python async best practices"
"lint code"
"format all files"

🔍 Key Features

✅ 38 comprehensive tools covering development workflows
✅ Natural language understanding with pattern matching
✅ Automatic tool selection and execution
✅ Self-reflection for quality improvement
✅ 4 operation modes (chat, command, tool, voice)
✅ Context awareness (projects, memory, sessions)
✅ Long-term memory (MEMORY.md) and daily notes
✅ Task and plan management
✅ Colored terminal output
✅ JSON/Text output formats
✅ Extensible architecture

📝 Notes

All tools work within /Users/walidsobhi/.openclaw/workspace/ by default
Context files (AGENTS.md, SOUL.md, TOOLS.md, USER.md) are automatically loaded
Memory file: MEMORY.md (append-only)
Session data: .tasks.json, .plans.json in workspace root
Voice mode requires optional dependencies

✅ Status

COMPLETE - Fully functional CLI and agent interface built, tested for imports, and documented.

To run: python stack.py or python -m stack_cli.cli

Dependencies: Install with pip install -e stack_cli/ (see pyproject.toml for full list)