Slash Commands Reference

Complete reference for all Zorora slash commands and workflows.

Overview

Slash commands force specific workflows, bypassing automatic routing. Use them when you want to ensure a particular workflow is executed.

Workflow Commands

/search

Force deep research workflow with multi-source synthesis

/search <query>

What it does:

1. Fetches newsroom headlines (if available, filters by relevance)
2. Searches the web (Brave Search API + DuckDuckGo fallback)
3. Searches academic databases (7 sources: Scholar, PubMed, CORE, arXiv, bioRxiv, medRxiv, PMC)
4. Synthesizes findings from all sources with citations
5. Returns comprehensive answer with source URLs

When to use:

• When you want to ensure web search is used (bypasses auto-routing)
• For current events or time-sensitive information
• When you need multiple source verification

Examples:

/search latest developments in renewable energy policy
/search bitcoin vs gold price movements in 2025
/search major AI trends in South America

Output format:

• Synthesized answer with inline citations ([Newsroom], [Web], [Academic])
• Source URLs listed at the end
• Mentions of domain names for web results

Configuration:

• Newsroom: 90 days back, max 25 relevant articles
• Web search: Brave API (primary) + DuckDuckGo (fallback)
• Academic: 7 sources searched in parallel
• Results cached (1 hour for general queries, 24 hours for stable topics)

/ask

Force conversational mode without web search

/ask <query>

What it does:

• Routes directly to reasoning model
• No web search, no tool calls
• Single-turn response based on model’s knowledge
• Fast response for follow-up questions

When to use:

• Follow-up questions about previous responses
• Meta conversations about output format
• Questions that don’t require current information
• Clarifications or explanations

Examples:

/ask can you explain that more simply?
/ask what did you mean by "virtual power plant"?
/ask how would I implement that in Python?

Model used: Reasoning model (qwen2.5:32b or configured alternative)

Note: Model knowledge cutoff may be outdated for current events. Use /search for time-sensitive queries.

/code

Force code generation with Codestral

/code <prompt>

What it does:

• Routes directly to Codestral specialist model
• Generates code with explanations
• Returns formatted code blocks
• No research or web search

When to use:

• Writing functions, classes, or scripts
• Code refactoring
• Algorithm implementation
• Quick code snippets

Examples:

/code write a function to parse JSON files with error handling
/code create a REST API endpoint for user authentication
/code refactor this function to use async/await

Model used: Codestral (local or HuggingFace endpoint)

• Local: qwen/qwen3-vl-4b (fast, basic)
• HF: Qwen2.5-Coder-32B-Instruct (high quality, slower)

Saving output:

> /code write a CSV parser
[Code generated...]
> /save csv_parser.py
Saved to: csv_parser.py

/develop

Multi-step code development workflow

/develop <development request>

What it does:

Phase 0: Pre-flight Checks

• Verifies git repository exists (required for safety)
• Warns if uncommitted changes present
• Asks for confirmation to proceed

Phase 1: Codebase Exploration

• Analyzes project structure and file types
• Detects project type (Node.js, Python, Go, Rust)
• Identifies framework (Express, Flask, Next.js, etc.)
• Reads configuration files (package.json, requirements.txt, etc.)
• Maps dependencies and entry points

Phase 2: Planning

• Uses reasoning model to create detailed plan
• Identifies files to create/modify
• Specifies dependencies to add
• Orders tasks logically
• Includes testing recommendations

Phase 3: User Approval

• Displays plan with rich formatting
• Asks for explicit approval
• User can approve, reject, or request modifications

Phase 4: Execution

• Executes approved plan step-by-step
• Uses Codestral for code generation
• Creates/modifies files as planned
• Handles errors gracefully

Phase 5: Lint & Validate

• Runs linters (ruff, eslint, etc.)
• Validates syntax
• Reports issues
• Suggests fixes

When to use:

• Adding features to existing codebase
• Refactoring large codebases
• Implementing complex functionality
• Multi-file changes

Examples:

/develop Add user authentication to my Flask app
/develop Refactor the API to use async/await
/develop Add unit tests for the user service

Requirements:

• Git repository must exist
• Uncommitted changes should be committed first
• Project must have recognizable structure

/image

Generate image with FLUX (text-to-image)

/image <prompt>

What it does:

• Generates image using FLUX.1-schnell model
• Text-to-image generation
• Returns image file path and displays image
• Fast generation (~5-15 seconds)

When to use:

• Creating visualizations
• Generating concept art
• Illustrating ideas
• Design mockups

Examples:

/image a futuristic solar farm at sunset
/image minimalist logo for an AI research company
/image detailed technical diagram of a battery storage system

Model used: black-forest-labs/FLUX.1-schnell

• Requires HuggingFace endpoint or local GPU
• Configure via /models command or Web UI settings

Output:

• Image saved to working directory
• Filename: flux_output_<timestamp>.png
• Image displayed in terminal (if supported)

Tips:

• Be descriptive and specific in prompts
• Include art style, lighting, perspective
• Mention colors, composition, mood

/vision

Analyze image with vision model (OCR and content extraction)

/vision <image_path> [optional task]

What it does:

• Analyzes image using vision-language model
• Extracts text (OCR)
• Describes visual content
• Converts to markdown format
• Optional custom analysis task

When to use:

• Extracting text from screenshots
• Analyzing charts and graphs
• Converting images to markdown
• Image content description

Examples:

/vision screenshot.png
/vision chart.png describe the trends shown
/vision diagram.jpg extract all labels and annotations
/vision receipt.png convert to structured data

Default task: “Convert this image to markdown format, preserving all text, tables, charts, and structure. Use OCR to extract any text.”

Model used: Vision-language model (qwen/qwen3-vl-4b)

Supported formats: PNG, JPG, JPEG, GIF, WebP

Output:

• Markdown-formatted text
• Tables preserved
• Structure maintained
• Text extracted and formatted

System Commands

/models

Interactive model selector

/models

What it does:

• Interactive menu for configuring models
• Select models for each tool
• Configure endpoints
• Set API keys

When to use:

• Initial setup
• Changing model configuration
• Testing different models

/config

Show current routing configuration

/config

What it does:

• Displays current model assignments
• Shows endpoint mappings
• Lists configured providers

When to use:

• Checking current configuration
• Debugging routing issues
• Verifying model assignments

/history

Browse saved conversation sessions

/history

What it does:

• Lists saved conversation sessions
• Shows session metadata (date, query count)
• Allows loading previous sessions

When to use:

• Reviewing past conversations
• Continuing previous research
• Finding specific queries

/help

Show available commands

/help

What it does:

• Displays list of all available commands
• Shows command syntax
• Provides brief descriptions

When to use:

• Learning available commands
• Quick reference
• Command discovery

exit, quit, q

Exit the REPL

exit
quit
q

What it does:

• Exits the REPL cleanly
• Saves conversation if auto-save enabled
• Restores terminal state

Natural Language Queries

Zorora automatically routes natural language queries to appropriate workflows:

Research queries (automatically routed to deep research):

What are the latest developments in LLM architectures?
Why do solar panels degrade over time?
How does battery storage work?

Code queries (automatically routed to code generation):

Write a function to validate email addresses
Create a REST API endpoint
Refactor this code to use async/await

Development queries (automatically routed to /develop):

Add user authentication to my Flask app
Refactor the API to use async/await
Add unit tests for the user service

Command Priority

Commands are processed in this order:

1. Slash commands - Highest priority, force specific workflows
2. File operations - Save, load, list, show, delete
3. Code generation - Write, create, generate + code keywords
4. Research queries - What, why, how, tell me keywords
5. Simple Q&A - Fallback to conversational mode

Tips & Best Practices

Use Slash Commands When:

• You want to force a specific workflow
• Auto-routing might choose wrong workflow
• You need predictable behavior
• Debugging workflow issues

Use Natural Language When:

• You want automatic routing
• Query intent is clear
• You trust the routing system
• Faster typing

Command Combinations:

# Research then code
/search latest Python async patterns
/code implement async pattern from research

# Code then develop
/code create user model
/develop add authentication using this model

# Image then vision
/image technical diagram of API architecture
/vision flux_output_*.png extract all labels

Troubleshooting

Command Not Recognized

Problem: Slash command not working

Solution:

• Check command spelling (case-sensitive)
• Verify command exists: /help
• Check for typos or extra spaces

Workflow Not Executing

Problem: Command runs but wrong workflow executes

Solution:

• Use explicit slash command to force workflow
• Check /config for routing configuration
• Verify model assignments

Command Hangs

Problem: Command takes too long or hangs

Solution:

• Check model endpoint connectivity
• Verify API keys are configured
• Check network connectivity (for remote endpoints)
• Review logs for errors

See Also

• Terminal REPL - Learn the command-line interface
• Research Workflow - Deep research capabilities
• Code Generation - Code generation guide
• Development Workflow - Multi-step development
• API Reference - Programmatic access