> ## Documentation Index
> Fetch the complete documentation index at: https://nikcli.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# FAQ

> Frequently Asked Questions about NikCLI

# Frequently Asked Questions

Get answers to the most common questions about NikCLI.

## 🚀 Getting Started

### What is NikCLI?

NikCLI is an advanced AI-powered development assistant that combines artificial intelligence with practical development tools. It features **cognitive orchestration** - an intelligent system that understands natural language tasks, breaks them down intelligently, and executes them using the most appropriate strategies.

### How is NikCLI different from other CLI tools?

Unlike traditional CLI tools, NikCLI features:

* **Cognitive Orchestration**: Advanced NLP-based task understanding
* **Dual Agent Architecture**: Universal Agent (35+ capabilities) and VM Agent (20+ capabilities)
* **Three Operating Modes**: Default Chat, Planning, and Auto Mode
* **Parallel Execution**: Intelligent concurrent task processing
* **Learning Capabilities**: Improves from each interaction

### What are the system requirements?

**Minimum Requirements:**

* Node.js 18+
* 4GB RAM
* 1GB free disk space
* Internet connection (for AI providers)

**Recommended:**

* Node.js 20+
* 8GB RAM
* 2GB free disk space
* Fast internet connection

### Which package managers are supported?

NikCLI supports all major package managers:

* npm
* yarn
* pnpm
* bun

The universal installer automatically detects and uses the best available package manager.

## 🤖 Agents and AI

### What is the Universal Agent?

The Universal Agent is NikCLI's flagship agent with **35 comprehensive capabilities**:

* **Core Development** (7): Code generation, analysis, review, optimization, debugging, refactoring, testing
* **Frontend Technologies** (11): React, Next.js, TypeScript, JavaScript, HTML, CSS, components, hooks, JSX, TSX
* **Backend Development** (8): Node.js, API development, databases, server architecture, REST, GraphQL, microservices
* **DevOps & Infrastructure** (8): CI/CD, Docker, Kubernetes, deployment, infrastructure, monitoring, security
* **Advanced Analysis** (5): Performance analysis, security analysis, quality assessment, architecture review, documentation generation

### What is the VM Agent?

The VM Agent is a **secure virtualized agent** with 20 specialized capabilities:

* **VM Operations** (7): vm-management, container-orchestration, isolated-execution, repository-cloning, vscode-server, autonomous-development, pull-request-automation
* **Repository Management** (5): repository-analysis, dependency-management, testing-automation, documentation-generation, code-quality-analysis
* **Security Features** (5): secure-api-communication, token-budget-management, audit-logging, resource-isolation, credential-management
* **Development Workflows** (3): full-stack-development, ci-cd-integration, git-operations, package-management, environment-setup

### How does cognitive orchestration work?

Cognitive orchestration uses advanced NLP to:

1. **Parse natural language** with 90%+ accuracy
2. **Extract entities** (files, components, APIs, databases)
3. **Assess complexity** and select optimal strategies
4. **Create execution plans** with phases and dependencies
5. **Learn patterns** from previous tasks

### Which AI providers are supported?

NikCLI supports multiple AI providers:

* **Anthropic Claude** (recommended)
* **OpenAI GPT**
* **Google Gemini**
* **Ollama** (local models)

## 🔧 Commands and Usage

### How many commands does NikCLI have?

NikCLI provides **70+ commands** organized into categories:

* **File Operations** (5): `/read`, `/write`, `/ls`, `/search`, `/find-files`, `/grep`
* **Terminal Commands** (12): `/run`, `/install`, `/npm`, `/git`, `/docker`, `/ps`, `/kill`
* **Project Management** (5): `/init`, `/build`, `/test`, `/lint`, `/analyze-project`
* **AI Model Commands** (5): `/models`, `/model`, `/temp`, `/set-key`, `/tokens`
* **Agent Management** (9): `/agents`, `/agent`, `/factory`, `/create-agent`, `/launch-agent`
* **Planning & Todo** (4): `/plan`, `/todo`, `/todos`, `/approval`
* **Parallel Execution** (8): `/parallel`, `/auto`, `/parallel-config`, `/parallel-monitor`
* **Security** (4): `/security`, `/dev-mode`, `/safe-mode`, `/clear-approvals`
* **VM Operations** (8): `/vm-create`, `/vm-list`, `/vm-connect`, `/vm-select`
* **Development Tools** (5): `/snapshot`, `/commits`, `/diff`, `/monitor`, `/diagnostic`
* **Memory & Data** (8): `/remember`, `/recall`, `/cache`, `/index`

### What are the three operating modes?

**Default Chat Mode (💬):**

* Interactive conversation with manual confirmation
* Step-by-step guidance
* Best for learning and experimentation

**Planning Mode (📋):**

* Strategic planning with comprehensive execution plans
* Todo.md file generation
* Approval workflows
* Best for complex projects

**Auto Mode (🤖):**

* Autonomous execution with minimal intervention
* Streamlined workflows
* Best for rapid development

### How do I switch between modes?

Use `Shift+Tab` to cycle through modes, or specific commands:

```bash theme={null}
/default    # Switch to Default Chat Mode
/plan       # Switch to Planning Mode
/auto       # Switch to Auto Mode
```

## ⚡ Parallel Execution

### What is parallel execution?

Parallel execution allows you to run multiple tasks simultaneously with intelligent coordination, dependency management, and resource optimization.

### How do I use parallel execution?

```bash theme={null}
# Basic parallel execution
/parallel "task1" "task2" "task3"

# With strategy
/parallel --strategy hybrid "Create frontend" "Build API" "Set up database"

# With dependencies
/parallel --dependencies {"task2": ["task1"]} "task1" "task2" "task3"
```

### What strategies are available?

* **Sequential**: Execute tasks one after another
* **Parallel**: Execute all tasks simultaneously
* **Hybrid**: Mix of parallel and sequential based on dependencies
* **Adaptive**: Dynamically adjust based on task characteristics

### How do I monitor parallel execution?

```bash theme={null}
# Monitor execution
/parallel-monitor

# View progress
/parallel-monitor --progress

# Check resources
/parallel-monitor --resources

# Control execution
/parallel-monitor --pause
/parallel-monitor --resume
```

## 🔒 Security and Privacy

### Is NikCLI secure?

Yes, NikCLI is designed with security in mind:

* **Local First**: Works entirely on your machine
* **Encrypted API Keys**: Secure storage with AES-256-GCM
* **Approval System**: Interactive confirmation for sensitive operations
* **Sandbox Mode**: Restricted execution environment
* **VM Isolation**: Secure virtualized development

### How are API keys stored?

API keys are stored securely in `~/.nikcli/config.json` with AES-256-GCM encryption. They are never transmitted to external servers except for the intended AI providers.

### What is the approval system?

The approval system requires user confirmation for sensitive operations:

* File write operations
* Command execution
* Network access
* Configuration changes

### Can I use NikCLI offline?

Yes, with local models:

```bash theme={null}
# Set up Ollama
/set-key ollama http://localhost:11434
/model ollama:llama3.1:8b

# Or enable offline mode
/config --offline-mode
```

## 🎯 Performance and Optimization

### How can I improve performance?

```bash theme={null}
# Enable caching
/cache --enable

# Optimize memory usage
/memory --optimize

# Reduce concurrency
/parallel-config --max-concurrent 2

# Use faster models
/model gpt-4o-mini
```

### What are the resource limits?

**Default Limits:**

* Memory: 2GB
* CPU: 4 cores
* Concurrent tasks: 3
* Timeout: 5 minutes

**Configurable:**

```bash theme={null}
/parallel-config --memory-limit 4GB --cpu-limit 8
/parallel-config --max-concurrent 6
```

### How do I monitor performance?

```bash theme={null}
# Check metrics
/stats

# Monitor resources
/memory --stats
/cpu --stats

# Check agent performance
/agents --metrics
```

## 🔧 Configuration

### Where is configuration stored?

Configuration is stored in `~/.nikcli/config.json`:

```json theme={null}
{
  "defaultProvider": "anthropic",
  "defaultModel": "claude-3-5-sonnet",
  "temperature": 0.7,
  "historyEnabled": true,
  "approvalLevel": "moderate"
}
```

### How do I backup my configuration?

```bash theme={null}
# Export configuration
/config --export backup-config.json

# Import configuration
/config --import backup-config.json
```

### Can I use environment variables?

Yes, you can set configuration via environment variables:

```bash theme={null}
export ANTHROPIC_API_KEY="sk-ant-api03-..."
export OPENAI_API_KEY="sk-..."
export NIKCLI_COMPACT=1
export NIKCLI_CLEAN_CHAT=1
```

## 🐛 Troubleshooting

### NikCLI is not responding

```bash theme={null}
# Check status
/agents

# Restart agents
/agent universal-agent --restart

# Check resources
/memory --stats

# Restart NikCLI
/quit
nikcli
```

### API keys not working

```bash theme={null}
# Check configuration
/config

# Test API connection
/debug

# Re-set API key
/set-key anthropic sk-ant-api03-...
```

### Parallel tasks hanging

```bash theme={null}
# Check resources
/parallel-monitor --resources

# Reduce concurrency
/parallel-config --max-concurrent 2

# Stop and restart
/parallel --kill
```

### Memory issues

```bash theme={null}
# Check memory usage
/memory --stats

# Clear caches
/cache --clear

# Reduce limits
/parallel-config --memory-limit 1GB
```

## 💰 Pricing and Limits

### Is NikCLI free?

NikCLI is open-source and free to use. You only pay for the AI provider API calls you make.

### What are the API costs?

Costs depend on your AI provider:

* **Anthropic Claude**: \~\$0.003 per 1K tokens
* **OpenAI GPT**: \~\$0.002 per 1K tokens
* **Google Gemini**: \~\$0.001 per 1K tokens
* **Ollama**: Free (local models)

### How can I reduce costs?

```bash theme={null}
# Use faster models
/model gpt-4o-mini
/model claude-3-5-haiku

# Enable caching
/cache --enable

# Use local models
/set-key ollama http://localhost:11434
```

## 🚀 Advanced Features

### How do I create custom agents?

```bash theme={null}
# Create specialized agent
/create-agent "React Expert" --specialization "react,typescript" --capabilities "component-design,ui-ux"

# Configure agent
/agent-config "React Expert" --style collaborative --verbosity detailed

# Use custom agent
/agent "React Expert" "Create a responsive navigation component"
```

### How do I use the VM Agent?

```bash theme={null}
# Create VM container
/vm-create https://github.com/user/repo.git

# Connect to VM
/vm-connect container-id

# Execute in VM
/agent vm-agent "Set up development environment"
```

### How do I use planning mode?

```bash theme={null}
# Switch to planning mode
/plan

# Create project plan
/plan "Build complete application"

# View todos
/todo

# Execute plan
/execute-plan
```

## 🤝 Community and Support

### Where can I get help?

* **Documentation**: [nikcli.mintlify.app](https://nikcli.mintlify.app)
* **GitHub Issues**: [github.com/nikomatt69/nikcli-main/issues](https://github.com/nikomatt69/nikcli-main/issues)
* **Discord Community**: [discord.gg/nikcli](https://discord.gg/nikcli)
* **Email Support**: [support@nikcli.dev](mailto:support@nikcli.dev)

### How can I contribute?

* **Report bugs**: Use GitHub Issues
* **Request features**: Use GitHub Discussions
* **Submit PRs**: Fork and submit pull requests
* **Improve docs**: Submit documentation improvements

### Is there enterprise support?

Yes, we offer enterprise support:

* **Email**: [enterprise@nikcli.dev](mailto:enterprise@nikcli.dev)
* **Training**: [training@nikcli.dev](mailto:training@nikcli.dev)
* **Consulting**: [consulting@nikcli.dev](mailto:consulting@nikcli.dev)

## 🎯 Next Steps

<CardGroup cols={2}>
  <Card title="Getting Started" icon="play" href="/quickstart/installation">
    Start using NikCLI
  </Card>

  <Card title="Examples" icon="book" href="/examples/basic-workflows">
    Learn through examples
  </Card>

  <Card title="Command Reference" icon="terminal" href="/cli-reference/commands-overview">
    Master all commands
  </Card>

  <Card title="Troubleshooting" icon="wrench" href="/troubleshooting/common-issues">
    Solve problems
  </Card>
</CardGroup>

<Tip>
  **Pro Tip:** Use `/help` at any time to see all available commands. NikCLI is context-aware and will show relevant options based on your current project and mode.
</Tip>