{
return this.callTool('query_tasks', { filter });
}
}
```
### Python
```python
import requests
import json
class TaskGeniusMCP:
def __init__(self, url, token, app_id):
self.url = url
self.headers = {
'Authorization': f'Bearer {token}+{app_id}',
'Content-Type': 'application/json'
}
self.session_id = None
def initialize(self):
response = requests.post(
self.url,
headers=self.headers,
json={
'jsonrpc': '2.0',
'id': 1,
'method': 'initialize'
}
)
self.session_id = response.headers.get('mcp-session-id')
def query_tasks(self, **filter):
return self.call_tool('query_tasks', {'filter': filter})
```
## Next Steps
* Explore [Use Cases](/docs/mcp-integration/use-cases) for practical examples
* Review [Client Configuration](/docs/mcp-integration/clients) for your tools
* Check [Troubleshooting](/docs/mcp-integration/troubleshooting) for common issues
**API Tip**: Always include a `limit` parameter in queries to prevent overwhelming responses. Start with small limits during development.
file: ./content/docs/mcp-integration/index.mdx
meta: {
"title": "MCP Integration Overview",
"description": "Complete guide to Model Context Protocol integration in Task Genius"
}
import { VersionCallout } from "@/components/VersionCallout";
# MCP Integration
Model Context Protocol (MCP) integration transforms Task Genius into an AI-powered task management powerhouse. This comprehensive guide will walk you through everything you need to know about setting up, configuring, and using MCP with your favorite AI tools.
## What is MCP?
Model Context Protocol (MCP) is an open standard developed by Anthropic that enables secure, standardized communication between AI assistants and external tools. In Task Genius, MCP allows AI assistants to:
* 📊 **Query and analyze** your task data with sophisticated filters
* ✨ **Create and update** tasks with full metadata support
* 🔄 **Batch process** multiple tasks efficiently
* 📈 **Generate insights** from your task patterns
* 🤖 **Automate workflows** based on your preferences
## Why Use MCP with Task Genius?
### Enhanced Productivity
Instead of manually managing tasks, you can now:
* Ask AI to organize your day based on priorities
* Generate task lists from meeting notes
* Automatically categorize and tag tasks
* Create recurring task templates
### Intelligent Task Management
AI can help you:
* Identify overdue tasks and suggest rescheduling
* Find patterns in your productivity
* Recommend task prioritization
* Generate progress reports
### 🔗 Seamless Integration
MCP works with:
* **Claude Desktop** - Anthropic's desktop AI assistant
* **Cursor** - AI-powered code editor
* **Claude Code** - Command-line AI assistant
* **VS Code** - With MCP extensions
* **Windsurf** - AI development environment
* **Zed** - Modern code editor
* **Custom Applications** - Via HTTP API
## Architecture Overview
```mermaid
graph TD
A[AI Assistant] -->|MCP Protocol| B[Task Genius MCP Server]
B --> C[Authentication Layer]
C --> D[Task Operations API]
D --> E[Dataflow Orchestrator]
E --> F[Your Tasks in Obsidian]
style A fill:#e1f5fe
style B fill:#fff3e0
style C fill:#ffebee
style D fill:#f3e5f5
style E fill:#e8f5e9
style F fill:#fce4ec
```
### Key Components
1. **MCP Server**: Built into Task Genius, runs locally on port 7777
2. **Authentication**: Token-based security with app ID verification
3. **Task API**: Comprehensive CRUD operations for task management
4. **Dataflow Integration**: Direct connection to Task Genius's task system
5. **Real-time Sync**: Changes reflect immediately in Obsidian
## Security Model
Task Genius implements multiple security layers:
### Authentication
* **Bearer Token**: Unique, auto-generated authentication token
* **App ID**: Vault-specific identifier for additional security
* **Combined Auth**: Support for both separate and combined authentication headers
### Access Control
* **Local-only by default**: Server binds to 127.0.0.1
* **Optional network access**: Can be configured for remote access
* **CORS support**: Configurable for web-based clients
### Security Best Practices
1. Never share your authentication token
2. Use local-only mode unless absolutely necessary
3. Regularly regenerate tokens if exposed
4. Monitor server logs for unauthorized access attempts
## Available Operations
Task Genius MCP provides 25+ tools organized into categories:
### Query Operations
* `query_tasks` - Advanced search with filters
* `query_project_tasks` - Get tasks by project
* `query_context_tasks` - Get tasks by context
* `query_by_priority` - Filter by priority level
* `query_by_due_date` - Find tasks in date ranges
* `search_tasks` - Full-text search
### Create Operations
* `create_task` - Create single task
* `create_task_in_daily_note` - Add to today's note
* `batch_create_tasks` - Create multiple tasks
* `batch_create_subtasks` - Add subtasks
### Update Operations
* `update_task` - Modify task properties
* `update_task_status` - Change completion
* `batch_update_task_status` - Bulk status changes
* `postpone_tasks` - Reschedule tasks
### Management Operations
* `list_all_metadata` - Get tags, projects, contexts
* `list_tasks_for_period` - Get tasks by time period
* `delete_task` - Remove tasks
## Quick Start
### Step 1: Enable MCP
Enable MCP Server
Or manually:
1. Open Obsidian Settings
2. Navigate to Task Genius → MCP Integration
3. Toggle "Enable MCP Server" ON
### Step 2: Note Your Credentials
After enabling, you'll see:
* **Server URL**: `http://127.0.0.1:7777/mcp`
* **Auth Token**: Auto-generated secure token
* **App ID**: Your vault's unique identifier
### Step 3: Configure Your AI Client
Choose your AI tool and follow the specific configuration guide:
### Step 4: Test Connection
Test MCP Connection
## What's Next?
* **[Client Configuration](/docs/mcp-integration/clients)** - Detailed setup for each AI tool
* **[API Reference](/docs/mcp-integration/api-reference)** - Complete tool documentation
* **[Use Cases](/docs/mcp-integration/use-cases)** - Practical examples and workflows
* **[Troubleshooting](/docs/mcp-integration/troubleshooting)** - Common issues and solutions
## System Requirements
* **Obsidian**: Version 0.15.2 or higher
* **Task Genius**: Version 9.0.0 or higher
* **Platform**: Desktop only (Windows, macOS, Linux)
* **Network**: Local network access (configurable)
* **Port**: 7777 (configurable)
## Getting Help
If you encounter issues:
1. Check the [Troubleshooting Guide](/docs/mcp-integration/troubleshooting)
2. Review server logs in Obsidian console (`Ctrl+Shift+I`)
3. Test connection using the built-in tester
4. Join our [Discord community](https://discord.gg/taskgenius)
5. Report bugs on [GitHub](https://github.com/yourusername/task-genius/issues)
**Pro Tip**: Start with local-only mode and basic queries before exploring advanced features. This helps you understand the system while maintaining security.
file: ./content/docs/mcp-integration/security.mdx
meta: {
"title": "MCP Security Best Practices",
"description": "Security guidelines and best practices for MCP integration"
}
This guide covers security considerations and best practices for using Task Genius MCP integration safely and securely.
## Security Overview
Task Genius MCP implements multiple security layers:
```mermaid
graph TD
A[AI Client] -->|HTTPS/HTTP| B[MCP Server]
B --> C[Authentication Layer]
C -->|Token Validation| D[Authorization]
D -->|App ID Verification| E[Session Management]
E -->|Scoped Access| F[Task Operations]
F -->|File System| G[Obsidian Vault]
style C fill:#ff9800
style D fill:#ff9800
style E fill:#ff9800
```
## Authentication & Authorization
### Token Security
**Token Generation:**
* Tokens are cryptographically random (32+ characters)
* Generated using secure random functions
* Unique per vault installation
**Token Storage:**
```javascript
// ✅ Good: Stored in Obsidian's secure settings
{
"mcpIntegration": {
"authToken": "encrypted_token_here"
}
}
// ❌ Bad: Hardcoded in configuration
const TOKEN = "abc123..."; // Never do this
```
**Token Rotation:**
Regenerate Token
Rotate tokens:
* Every 90 days (recommended)
* After any suspected compromise
* When changing access patterns
* Before major vault migrations
### App ID Protection
The App ID provides an additional security layer:
```http
Authorization: Bearer TOKEN+APP_ID
```
Benefits:
* Vault-specific identification
* Prevents token reuse across vaults
* Enables audit trails
* Supports multi-vault setups
## Network Security
### Local-Only Mode (Default)
**Configuration:**
```json
{
"host": "127.0.0.1", // Local only
"port": 7777
}
```
**Security benefits:**
* No external network access
* Protected from remote attacks
* No firewall configuration needed
* Ideal for single-user setups
### Network Access Mode
**⚠️ Only enable if necessary:**
```json
{
"host": "0.0.0.0", // All interfaces - USE WITH CAUTION
"port": 7777
}
```
**Required protections:**
1. **Firewall Rules:**
```bash
# Allow only specific IPs
iptables -A INPUT -p tcp --dport 7777 -s 192.168.1.0/24 -j ACCEPT
iptables -A INPUT -p tcp --dport 7777 -j DROP
```
2. **VPN/Tunnel:**
```bash
# Use SSH tunnel instead of direct exposure
ssh -L 7777:localhost:7777 user@remote-host
```
3. **Reverse Proxy with SSL:**
```nginx
server {
listen 443 ssl;
ssl_certificate /path/to/cert.pem;
ssl_certificate_key /path/to/key.pem;
location /mcp {
proxy_pass http://127.0.0.1:7777;
proxy_set_header Authorization $http_authorization;
}
}
```
## Data Protection
### Sensitive Information
**Never expose in tasks:**
* Passwords or API keys
* Personal identification numbers
* Credit card information
* Private keys or certificates
* Medical/financial data
**Use references instead:**
```markdown
- [ ] Update database password to "MyS3cr3tP@ss"
- [ ] Update database password (see vault)
```
### Vault Encryption
**Enable Obsidian vault encryption:**
1. Use encrypted disk/volume:
```bash
# macOS FileVault
sudo fdesetup enable
# Linux LUKS
cryptsetup luksFormat /dev/sdX
# Windows BitLocker
manage-bde -on C:
```
2. Sync with encrypted services:
* Use end-to-end encrypted sync
* Enable 2FA on cloud services
* Avoid public/shared folders
### Backup Security
**Secure backup practices:**
```bash
# Encrypted backup
tar -czf - /path/to/vault | \
openssl enc -aes-256-cbc -salt -out vault-backup.tar.gz.enc
# Restore
openssl dec -aes-256-cbc -in vault-backup.tar.gz.enc | \
tar -xzf -
```
## Access Control
### Client Authentication
**Verify client identity:**
```json
{
"allowedClients": [
"Claude Desktop",
"Cursor",
"Custom App"
],
"requireClientCert": false, // Future feature
"ipWhitelist": [
"127.0.0.1",
"192.168.1.100"
]
}
```
### Rate Limiting
**Prevent abuse:**
```javascript
// Recommended limits
{
"rateLimits": {
"requestsPerSecond": 10,
"requestsPerMinute": 100,
"maxConcurrent": 5,
"maxResponseSize": 10485760 // 10MB
}
}
```
### Session Management
**Session security:**
* Sessions expire after inactivity (default: 1 hour)
* Unique session ID per connection
* Sessions bound to IP address
* No session sharing between clients
## Audit & Monitoring
### Enable Logging
**Set appropriate log level:**
```json
{
"logLevel": "info", // For production
"logFile": "/path/to/mcp-audit.log",
"logRotation": {
"maxSize": "10MB",
"maxFiles": 10
}
}
```
### Monitor Access Patterns
**Watch for suspicious activity:**
```bash
# Check access logs
grep "401\|403" mcp-audit.log # Unauthorized attempts
grep "DELETE" mcp-audit.log # Deletion operations
grep -c "query_tasks" mcp-audit.log | sort -n # Excessive queries
```
**Alert triggers:**
* Multiple failed authentication attempts
* Unusual query patterns
* Mass deletion requests
* Access from unexpected IPs
### Security Events
**Log security-relevant events:**
```javascript
// Events to monitor
{
"events": [
"auth.failed", // Failed authentication
"auth.success", // Successful login
"token.regenerated", // Token rotation
"task.deleted", // Data deletion
"config.changed", // Configuration updates
"server.started", // Server lifecycle
"server.stopped"
]
}
```
## Secure Configuration Examples
### Development Environment
```json
{
"mcpIntegration": {
"enabled": true,
"host": "127.0.0.1",
"port": 7777,
"authToken": "dev_token_only",
"enableCors": true,
"logLevel": "debug"
}
}
```
### Production Environment
```json
{
"mcpIntegration": {
"enabled": true,
"host": "127.0.0.1",
"port": 7777,
"authToken": "${MCP_AUTH_TOKEN}", // From environment
"enableCors": false,
"logLevel": "warning",
"ssl": {
"enabled": true,
"cert": "/path/to/cert.pem",
"key": "/path/to/key.pem"
}
}
}
```
### Team Environment
```json
{
"mcpIntegration": {
"enabled": true,
"host": "0.0.0.0",
"port": 7777,
"authToken": "${TEAM_MCP_TOKEN}",
"enableCors": true,
"ipWhitelist": [
"192.168.1.0/24", // Office network
"10.0.0.0/8" // VPN range
],
"requireHttps": true,
"logLevel": "info"
}
}
```
## Security Checklist
### Initial Setup
* [ ] Generate strong authentication token
* [ ] Store credentials securely
* [ ] Configure local-only access by default
* [ ] Enable appropriate logging
* [ ] Test authentication before use
* [ ] Document security configuration
### Regular Maintenance
* [ ] Rotate tokens quarterly
* [ ] Review access logs monthly
* [ ] Update Task Genius regularly
* [ ] Audit client configurations
* [ ] Test backup/restore procedures
* [ ] Review firewall rules
### Incident Response
If you suspect a security breach:
1. **Immediate Actions:**
* [ ] Disable MCP server
* [ ] Regenerate all tokens
* [ ] Review recent access logs
* [ ] Check for unauthorized changes
2. **Investigation:**
* [ ] Identify breach timeline
* [ ] Determine data accessed
* [ ] Find attack vector
* [ ] Document findings
3. **Recovery:**
* [ ] Restore from secure backup
* [ ] Implement additional controls
* [ ] Update security procedures
* [ ] Notify affected parties if needed
## Common Vulnerabilities
### 1. Token Exposure
**Risk:** Tokens in version control
**Prevention:**
```bash
# .gitignore
*.json
config.json
.env
**/data.json
```
**Detection:**
```bash
# Scan for exposed tokens
git grep -E "Bearer [a-zA-Z0-9+/]{32,}"
```
### 2. Insecure Transport
**Risk:** Token interception on network
**Mitigation:**
* Use HTTPS when possible
* Implement VPN for remote access
* Use SSH tunnels for security
* Never use public WiFi unprotected
### 3. Excessive Permissions
**Risk:** Overly broad access
**Mitigation:**
* Principle of least privilege
* Separate read/write tokens (future)
* Time-based access controls
* Regular permission audits
## Compliance Considerations
### GDPR Compliance
If handling EU personal data:
* Implement data minimization
* Provide data export capabilities
* Enable deletion rights
* Maintain audit logs
* Document data processing
### HIPAA Compliance
For healthcare-related tasks:
* Encrypt data at rest and in transit
* Implement access controls
* Maintain audit trails
* Regular security assessments
* Business Associate Agreements
### SOC 2 Requirements
For enterprise use:
* Document security policies
* Regular vulnerability assessments
* Incident response procedures
* Change management processes
* Third-party audits
## Security Tools
### Testing Tools
```bash
# Test authentication
curl -X POST http://127.0.0.1:7777/mcp \
-H "Authorization: Bearer INVALID" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize"}'
# Should return 401
# Test rate limiting
for i in {1..100}; do
curl -X POST http://127.0.0.1:7777/health &
done
# Should see rate limit errors
# Port scanning
nmap -p 7777 127.0.0.1
# Should show only expected port
```
### Monitoring Scripts
```bash
#!/bin/bash
# monitor-mcp.sh
# Check for failed auth attempts
FAILURES=$(grep -c "401" /var/log/mcp.log)
if [ $FAILURES -gt 10 ]; then
echo "Warning: $FAILURES failed auth attempts"
# Send alert
fi
# Check for unusual activity
DELETES=$(grep -c "delete_task" /var/log/mcp.log)
if [ $DELETES -gt 50 ]; then
echo "Warning: Unusual deletion activity"
# Investigate
fi
```
## Recommendations by Use Case
### Personal Use
* Local-only access (127.0.0.1)
* Simple token authentication
* Minimal logging
* Regular backups
### Small Team
* VPN-based access
* Shared token with rotation
* Info-level logging
* Encrypted backups
### Enterprise
* Zero-trust network model
* Certificate-based auth
* Comprehensive audit logging
* Automated security scanning
* Regular penetration testing
## Next Steps
* Review [troubleshooting guide](/docs/mcp-integration/troubleshooting) for security-related issues
* Implement [monitoring and alerting](/docs/mcp-integration/monitoring)
* Join [security discussions](https://discord.gg/taskgenius-security)
* Report security issues privately to [security@taskgenius.app](mailto:security@taskgenius.app)
**Security Report**: If you discover a security vulnerability, please report it privately to [security@taskgenius.app](mailto:security@taskgenius.app). Do not create public issues for security problems.
file: ./content/docs/mcp-integration/troubleshooting.mdx
meta: {
"title": "MCP Troubleshooting & FAQ",
"description": "Solutions to common issues and frequently asked questions"
}
This guide helps you resolve common issues with Task Genius MCP integration and answers frequently asked questions.
## Quick Diagnostics
Before troubleshooting, run these checks:
### Step 1: Verify Server Status
Check MCP Status
Look for:
* \[MCP Test] Server running (green indicator)
* \[MCP Test] Port number displayed
* \[MCP Test] No error messages
### Step 2: Test Connection
Run Connection Test
Expected result:
```text
[MCP Test] Health check passed
[MCP Test] Initialize successful
[MCP Test] Tools list retrieved
```
### Step 3: Check Logs
Open Obsidian Developer Console:
* Windows/Linux: `Ctrl + Shift + I`
* macOS: `Cmd + Option + I`
Look for entries starting with `[MCP Test]`
## Common Issues
### Server Won't Start
#### Symptoms
* Red "Stopped" indicator in settings
* "Failed to start server" error
* No response from health endpoint
#### Solutions
**1. Port Already in Use**
Check if port 7777 is occupied:
```bash
# Windows
netstat -ano | findstr :7777
# macOS/Linux
lsof -i :7777
```
Fix:
* Kill the process using the port, OR
* Change to a different port in settings, OR
* Use "Next Available Port" button
**2. Permission Issues**
On macOS/Linux:
```bash
# Check permissions
ls -la ~/.obsidian/plugins/Obsidian-Task-Genius/
# Fix permissions if needed
chmod -R 755 ~/.obsidian/plugins/Obsidian-Task-Genius/
```
**3. Firewall Blocking**
* Add Obsidian to firewall exceptions
* Allow localhost connections (127.0.0.1)
* For network access, allow port 7777
**4. Plugin Not Fully Loaded**
1. Disable Task Genius plugin
2. Restart Obsidian
3. Enable Task Genius plugin
4. Wait 5 seconds before enabling MCP
### Authentication Failures
#### Symptoms
* "Unauthorized" errors
* "Invalid token" messages
* Session not established
#### Solutions
**1. Token Format Issues**
Check your token format:
❌ Wrong:
```json
"Authorization": "YOUR_TOKEN+YOUR_APP_ID"
```
✅ Correct:
```json
"Authorization": "Bearer YOUR_TOKEN+YOUR_APP_ID"
```
**2. Token Expired or Changed**
Regenerate Token
Then update all client configurations.
**3. Missing App ID**
Ensure your App ID is included:
```bash
# Find your App ID in settings or console
console.log(app.appId) // Shows something like "obsdmd1234567"
```
**4. Header Configuration**
Verify headers in your client:
Method A (Separate):
```json
{
"Authorization": "Bearer YOUR_TOKEN",
"mcp-app-id": "YOUR_APP_ID"
}
```
Method B (Combined):
```json
{
"Authorization": "Bearer YOUR_TOKEN+YOUR_APP_ID"
}
```
### Connection Issues
#### Symptoms
* "Connection refused" errors
* Timeouts
* "Cannot reach server"
#### Solutions
**1. Server Not Running**
Check and restart:
1. Open MCP settings
2. Toggle server OFF
3. Wait 2 seconds
4. Toggle server ON
5. Check status indicator
**2. Network Configuration**
For local access:
```json
{
"host": "127.0.0.1", // Local only
"port": 7777
}
```
For network access:
```json
{
"host": "0.0.0.0", // All interfaces
"port": 7777
}
```
**3. Client URL Issues**
Common mistakes:
❌ Wrong:
* `http://localhost:7777/mcp/` (trailing slash)
* `https://127.0.0.1:7777/mcp` (HTTPS not supported)
* `http://127.0.0.1:7777` (missing /mcp)
✅ Correct:
* `http://127.0.0.1:7777/mcp`
* `http://192.168.1.100:7777/mcp` (for network)
**4. Proxy/VPN Interference**
* Disable VPN temporarily
* Check proxy settings
* Use direct connection
### Tool Execution Errors
#### Symptoms
* "Tool not found" errors
* "Invalid parameters"
* Unexpected results
#### Solutions
**1. Session Not Initialized**
Always initialize first:
```bash
curl -X POST http://127.0.0.1:7777/mcp \
-H "Authorization: Bearer TOKEN+APPID" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize"}'
```
**2. Missing Session ID**
Include session ID in subsequent requests:
```bash
-H "mcp-session-id: session_abc123"
```
**3. Parameter Validation**
Check parameter types:
❌ Wrong:
```json
{
"priority": "high", // Should be number
"dueDate": "tomorrow", // Should be YYYY-MM-DD
"completed": "yes" // Should be boolean
}
```
✅ Correct:
```json
{
"priority": 5,
"dueDate": "2024-01-20",
"completed": true
}
```
**4. Tool Name Typos**
Use exact tool names:
* ✅ `query_tasks` (correct)
* ❌ `queryTasks` (wrong)
* ❌ `query-tasks` (wrong)
### Performance Issues
#### Symptoms
* Slow responses
* Timeouts
* High CPU usage
#### Solutions
**1. Large Result Sets**
Always use limits:
```json
{
"limit": 100, // Reasonable limit
"offset": 0 // For pagination
}
```
**2. Inefficient Queries**
Optimize your filters:
❌ Inefficient:
```json
{
"filter": {} // Gets all tasks
}
```
✅ Efficient:
```json
{
"filter": {
"completed": false,
"project": "Current"
},
"limit": 50
}
```
**3. Indexing Issues**
Rebuild task index:
1. Settings → Task Genius → Index & Sources
2. Click "Rebuild Index"
3. Wait for completion
4. Restart MCP server
**4. Memory Management**
For large vaults:
* Increase Obsidian memory limit
* Close unused plugins
* Restart Obsidian periodically
## Platform-Specific Issues
### macOS
**Issue: Security Warnings**
Solution:
```bash
# Allow Obsidian network access
System Preferences → Security & Privacy → Firewall → Options
Add Obsidian to allowed apps
```
**Issue: Port Binding Failed**
Solution:
```bash
# Check System Integrity Protection
csrutil status
# If needed, use a higher port number (> 1024)
```
### Windows
**Issue: Windows Defender Blocking**
Solution:
1. Windows Security → Firewall & network protection
2. Allow an app through firewall
3. Add Obsidian.exe
4. Check both Private and Public
**Issue: PowerShell Execution Policy**
For Claude Desktop/CLI tools:
```powershell
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
```
### Linux
**Issue: Permission Denied**
Solution:
```bash
# For ports < 1024
sudo setcap 'cap_net_bind_service=+ep' /usr/bin/obsidian
# Or use a higher port
```
**Issue: SELinux Blocking**
Solution:
```bash
# Check SELinux status
sestatus
# Allow if needed
setsebool -P httpd_can_network_connect 1
```
## Client-Specific Issues
### Cursor
**Issue: Configuration Not Loading**
1. Verify config file location
2. Check JSON syntax
3. Restart Cursor
4. Clear Cursor cache
### Claude Desktop
**Issue: Curl Command Failing**
Test manually:
```bash
curl -v -X POST http://127.0.0.1:7777/mcp \
-H "Authorization: Bearer TOKEN+APPID" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize"}'
```
Common fixes:
* Install/update curl
* Check PATH variable
* Use full curl path
### VS Code
**Issue: Extension Not Recognizing MCP**
1. Update VS Code
2. Reinstall MCP extension
3. Check workspace settings
4. Verify configuration scope
## Frequently Asked Questions
### General
**Q: Is MCP secure?**
A: Yes, MCP uses token-based authentication and runs locally by default. For additional security:
* Keep tokens secret
* Use local-only mode
* Regenerate tokens periodically
* Monitor access logs
**Q: Can I use MCP on mobile?**
A: No, MCP requires desktop Obsidian due to technical limitations of mobile platforms.
**Q: Does MCP work offline?**
A: Yes, MCP runs entirely locally. Internet is only needed for AI services (Claude, ChatGPT, etc.).
**Q: Can multiple AI tools connect simultaneously?**
A: Yes, multiple clients can connect to the same MCP server. Each gets its own session.
### Configuration
**Q: How do I change the port?**
A: Settings → MCP Integration → Port → Enter new number → Restart server
**Q: Can I run multiple MCP servers?**
A: Yes, for different vaults:
1. Use different ports (7777, 7778, etc.)
2. Each vault has unique tokens
3. Configure clients separately
**Q: Should I use Method A or Method B authentication?**
A: Method B (combined Bearer) is recommended for simplicity. Use Method A if your client doesn't support combined headers.
**Q: How do I allow remote access?**
A: Change host from `127.0.0.1` to `0.0.0.0` and ensure firewall allows the port. ⚠️ Understand security implications first.
### Usage
**Q: Why are my queries slow?**
A: Common causes:
* Large vault (10,000+ tasks)
* No query limits
* Inefficient filters
* Index needs rebuilding
**Q: Can I modify task files directly?**
A: Yes, MCP modifications are the same as manual edits. Files update in real-time.
**Q: What happens if Obsidian crashes?**
A: MCP server stops with Obsidian. Restart Obsidian and re-enable MCP. No data is lost.
**Q: How do I backup my MCP configuration?**
A: Configuration is stored in Obsidian settings. Backup:
* `.obsidian/plugins/obsidian-task-genius/data.json`
* Client configuration files
### Limits
**Q: What are the rate limits?**
A: No hard limits, but recommended:
* Max 100 requests/second
* Result sets \< 1000 items
* Batch operations \< 500 items
**Q: Maximum task content length?**
A:
* Task content: 10,000 characters
* Tags: 50 per task
* File path: 260 characters (OS limit)
**Q: How many concurrent connections?**
A: Theoretical: Unlimited
Practical: 10-20 for optimal performance
## Debug Commands
### Test Basic Connectivity
```bash
# Health check
curl http://127.0.0.1:7777/health
# Expected: {"status":"ok","version":"1.0.0"}
```
### Test Authentication
```bash
# With your actual token and app ID
curl -X POST http://127.0.0.1:7777/mcp \
-H "Authorization: Bearer YOUR_TOKEN+YOUR_APP_ID" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize"}'
```
### Test Tool Execution
```bash
# List available tools
curl -X POST http://127.0.0.1:7777/mcp \
-H "Authorization: Bearer YOUR_TOKEN+YOUR_APP_ID" \
-H "mcp-session-id: YOUR_SESSION_ID" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'
```
### Enable Debug Logging
In MCP settings, set Log Level to "Debug", then check console:
```javascript
// In Obsidian console
console.log(app.plugins.plugins['obsidian-task-genius'].mcpServerManager.getStatus())
```
## Getting Help
If these solutions don't resolve your issue:
1. **Gather Information**:
* Obsidian version
* Task Genius version
* Error messages
* Console logs
* Steps to reproduce
2. **Check Resources**:
* [GitHub Issues](https://github.com/yourusername/task-genius/issues)
* [Discord Community](https://discord.gg/taskgenius)
* [Documentation](https://taskgenius.docs)
3. **Report Issue**:
* Use GitHub issue template
* Include diagnostic info
* Describe expected vs actual behavior
* Attach relevant logs
**Security Note**: When sharing logs or configuration, always redact authentication tokens and sensitive information.
## Recovery Procedures
### Reset MCP Configuration
1. Disable MCP server
2. Close Obsidian
3. Delete MCP cache: `.obsidian/plugins/obsidian-task-genius/.mcp-cache`
4. Restart Obsidian
5. Re-enable MCP
6. Regenerate token
7. Reconfigure clients
### Full Plugin Reset
If all else fails:
1. Export your settings (backup `data.json`)
2. Disable Task Genius
3. Delete plugin folder
4. Reinstall Task Genius
5. Import settings
6. Re-enable MCP
**Remember**: MCP is a powerful feature but still in active development. Report bugs to help improve it for everyone!
file: ./content/docs/mcp-integration/use-cases.mdx
meta: {
"title": "MCP Use Cases & Examples",
"description": "Practical examples and workflows for Task Genius MCP integration"
}
This guide demonstrates real-world applications of Task Genius MCP integration, from simple daily workflows to complex automation scenarios.
## Daily Task Management
### Morning Planning Routine
Start your day by asking AI to organize your tasks:
```text
"Show me all tasks due today, sorted by priority.
Include any overdue tasks from yesterday."
```
The AI will:
1. Query incomplete tasks due today
2. Find overdue tasks from previous days
3. Sort by priority (5 = highest)
4. Present a organized daily plan
**Behind the scenes:**
```json
{
"method": "tools/call",
"params": {
"name": "query_tasks",
"arguments": {
"filter": {
"completed": false,
"dateRange": {
"from": "2024-01-01",
"to": "2024-01-15"
}
},
"sort": {
"field": "priority",
"order": "desc"
}
}
}
}
```
### End-of-Day Review
Review what you accomplished:
```text
"What tasks did I complete today?
Generate a summary for my daily log."
```
**Result:**
```markdown
## Daily Accomplishments - January 15, 2024
### Completed Tasks (7)
- ✅ [High] Review Q1 budget proposal
- ✅ [High] Client meeting preparation
- ✅ [Medium] Update project documentation
- ✅ [Medium] Code review for feature branch
- ✅ [Low] Respond to team emails
- ✅ [Low] Update calendar for next week
- ✅ [Low] File expense reports
### Progress Summary
- Completion rate: 70% (7/10 tasks)
- High-priority completion: 100% (2/2)
- Projects touched: Budget Planning, Client Relations, Development
```
### Weekly Planning
Prepare for the upcoming week:
```text
"Create a weekly overview:
1. Tasks due this week by day
2. Project milestones
3. Recurring tasks to schedule"
```
## Project Management
### Sprint Planning
Set up a new sprint with AI assistance:
```text
"Create sprint tasks for Project Alpha:
- Setup development environment (Priority 5, Due: Monday)
- Design database schema (Priority 4, Due: Tuesday)
- Implement user authentication (Priority 5, Due: Thursday)
- Write unit tests (Priority 4, Due: Friday)
- Code review and merge (Priority 3, Due: Friday)
Tag all with #sprint-01 and +ProjectAlpha"
```
**MCP executes:**
```json
{
"name": "batch_create_tasks",
"arguments": {
"defaultFilePath": "Projects/Sprint-01.md",
"tasks": [
{
"content": "Setup development environment",
"priority": 5,
"dueDate": "2024-01-15",
"project": "ProjectAlpha",
"tags": ["sprint-01"]
},
// ... more tasks
]
}
}
```
### Project Status Report
Generate project insights:
```text
"Analyze Project Alpha:
- How many tasks are complete vs incomplete?
- What high-priority items are overdue?
- What's the completion trend this month?"
```
**AI Response:**
```markdown
## Project Alpha Status Report
### Overview
- Total Tasks: 47
- Completed: 31 (66%)
- In Progress: 12 (26%)
- Not Started: 4 (8%)
### Critical Items (Overdue + High Priority)
1. API Integration - 3 days overdue
2. Security Audit - 1 day overdue
### This Month's Progress
- Week 1: 5 tasks completed
- Week 2: 8 tasks completed
- Week 3: 12 tasks completed (current)
- Trend: Accelerating ↗️
### Recommendations
- Focus on overdue high-priority items
- API Integration blocks 3 other tasks
- Consider redistributing Week 4 workload
```
### Milestone Tracking
Track project milestones:
```text
"Show all milestones for Q1 projects.
Highlight any at risk of missing deadline."
```
## Meeting Management
### Pre-Meeting Preparation
Before a meeting:
```text
"Prepare for tomorrow's client meeting:
1. Find all tasks related to ClientX
2. Identify discussion points
3. Create action items template"
```
**AI generates:**
```markdown
## ClientX Meeting Prep - January 16, 2024
### Open Items (5)
- Contract renewal discussion (Due: Jan 20)
- Feature request: Dashboard customization
- Bug report: Login timeout issue
- Q1 roadmap review
- Budget allocation for add-ons
### Completed Since Last Meeting (3)
- ✅ Fixed data export issue
- ✅ Deployed performance improvements
- ✅ Updated documentation
### Suggested Agenda
1. Review completed items (5 min)
2. Address bug report (10 min)
3. Discuss feature request (15 min)
4. Q1 roadmap alignment (20 min)
5. Contract and budget (10 min)
### Action Items Template
- [ ] [Owner] Action description (Due: Date)
- [ ] [Owner] Action description (Due: Date)
```
### Post-Meeting Actions
After the meeting:
```text
"Create tasks from these meeting notes:
- John: Send proposal by Friday (high priority)
- Sarah: Review legal docs by next Tuesday
- Me: Update dashboard mockups by Monday
- Team: Schedule follow-up for next month
All tasks should be tagged #ClientX"
```
## Automation Workflows
### Recurring Task Generation
Set up recurring tasks:
```text
"Create weekly recurring tasks:
- Monday: Team standup prep
- Wednesday: Progress report
- Friday: Week review and planning
All should be medium priority, tagged #recurring"
```
### Task Migration
Move tasks between projects:
```text
"Find all tasks tagged #prototype in the Research project
and move them to the Development project.
Update their priority to 4."
```
**MCP operations:**
1. Query tasks with specific criteria
2. Batch update project assignment
3. Update priority levels
4. Confirm changes
### Bulk Status Updates
End-of-sprint cleanup:
```text
"Mark all tasks in Sprint-01 as complete
except those tagged #carry-over.
Move carry-over tasks to Sprint-02."
```
## Time Management
### Time Blocking
Create time-blocked tasks:
```text
"Create time blocks for tomorrow:
- 9:00-10:00: Deep work on API design
- 10:00-10:30: Email and messages
- 10:30-12:00: Development sprint
- 13:00-14:00: Code review
- 14:00-15:00: Team meeting
- 15:00-17:00: Feature implementation"
```
### Focus Sessions
Set up focused work sessions:
```text
"Create a 2-hour focus block:
1. Set main task: Complete user authentication
2. Add subtasks:
- Review requirements (15 min)
- Write implementation (60 min)
- Write tests (30 min)
- Document changes (15 min)"
```
## Data Analysis
### Productivity Metrics
Analyze your productivity:
```text
"Analyze my task completion for the past month:
- Average daily completion rate
- Most productive day of week
- Which projects take most time
- Priority distribution"
```
**AI Analysis:**
```markdown
## Productivity Analysis - Last 30 Days
### Completion Metrics
- Total tasks completed: 127
- Average per day: 4.2 tasks
- Completion rate: 78%
### Best Performance
- Most productive: Tuesdays (6.1 tasks avg)
- Peak hours: 9 AM - 12 PM
- Best week: Week 2 (34 tasks)
### Project Distribution
1. Client Work: 45% of tasks
2. Internal Development: 30%
3. Administration: 15%
4. Learning: 10%
### Priority Insights
- High priority completion: 92%
- Medium priority completion: 78%
- Low priority completion: 65%
- Recommendation: Delegate more low-priority tasks
```
### Workload Balancing
Balance your workload:
```text
"Analyze my workload for next week:
- Which days are overloaded?
- What can be postponed?
- Suggest a balanced schedule"
```
## Advanced Integrations
### Cross-Tool Workflows
Integrate with other tools:
```text
"When I mention a task in my code comments like:
// TODO: Implement caching mechanism
Create a corresponding task in Obsidian with:
- Context from the file path
- Priority based on TODO/FIXME/HACK
- Tag with #code-todo"
```
### Email to Task
Convert emails to tasks:
```text
"Create tasks from this email thread:
Subject: Project Requirements Update
- Review new requirements doc (High, Due: Friday)
- Update implementation plan (Medium, Due: Monday)
- Schedule stakeholder meeting (Low, Due: Next week)"
```
### Calendar Integration
Sync with calendar events:
```text
"For each meeting in my calendar tomorrow:
- Create a prep task 30 minutes before
- Create a follow-up task for the day after
- Tag with #meeting and the attendee names"
```
## Team Collaboration
### Task Delegation
Delegate tasks to team members:
```text
"From my current tasks, identify which ones could be delegated:
- Technical tasks → Dev team
- Documentation → Technical writer
- Testing → QA team
Create delegation templates for each."
```
### Team Status Dashboard
Create team overview:
```text
"Generate team status dashboard:
- Tasks by team member
- Overdue items per person
- This week's priorities
- Blockers and dependencies"
```
**Generated Dashboard:**
```markdown
## Team Status - Week 3
### Task Distribution
- Alice: 12 tasks (3 high priority)
- Bob: 8 tasks (2 high priority)
- Carol: 10 tasks (4 high priority)
- David: 7 tasks (1 high priority)
### ⚠️ Overdue Items
- Alice: API documentation (2 days)
- Carol: Test suite update (1 day)
### This Week's Priorities
1. Complete Sprint-01 deliverables
2. Client presentation preparation
3. Security audit response
4. Q2 planning kickoff
### Blockers
- Waiting on design approval (affects 3 tasks)
- Database migration pending (affects 5 tasks)
```
## Custom Workflows
### Personal Routines
Create personalized workflows:
```text
"My morning routine:
1. Check overdue tasks
2. Review today's calendar
3. Set 3 main priorities
4. Time block the morning
5. Create focus session for deep work"
```
### Context Switching
Manage context switches:
```text
"I'm switching from Project A to Project B:
1. Save current state of Project A tasks
2. Mark in-progress items
3. Load Project B context
4. Show Project B priorities
5. Suggest starting point"
```
### Review Cycles
Set up review processes:
```text
"Weekly review process:
1. List completed tasks
2. Identify incomplete high-priority items
3. Analyze why tasks weren't completed
4. Adjust next week's priorities
5. Archive completed project tasks"
```
## Tips for Effective Use
### 1. Start Simple
Begin with basic queries before complex automation:
* ❌ "Reorganize my entire task system"
* ✅ "Show today's high-priority tasks"
### 2. Be Specific
Provide clear criteria for better results:
* ❌ "Find important stuff"
* ✅ "Find tasks with priority 4-5 due this week"
### 3. Use Natural Language
The AI understands context:
* "What should I work on now?"
* "Help me plan tomorrow"
* "I'm overwhelmed, prioritize my tasks"
### 4. Iterate and Refine
Adjust queries based on results:
1. Start broad: "Show project tasks"
2. Refine: "Show incomplete project tasks"
3. Focus: "Show incomplete high-priority project tasks due this week"
### 5. Create Templates
Save successful workflows:
```javascript
const dailyReview = `
Show me:
1. What I completed today
2. What's still pending
3. Tomorrow's priorities
4. Any new urgent items
`;
```
## Next Steps
* Review [API Reference](/docs/mcp-integration/api-reference) for detailed parameters
* Explore [Client Configurations](/docs/mcp-integration/clients) for your tools
* Check [Troubleshooting](/docs/mcp-integration/troubleshooting) if you encounter issues
* Share your workflows with the community
**Pro Tip**: Save your most effective AI prompts as templates. This creates consistent, reliable workflows you can reuse daily.
file: ./content/docs/task-view/basic-view-settings.mdx
meta: {
"title": "Basic view settings"
}
import { VersionCallout } from "@/components/VersionCallout";
## Basic Settings
View settings are available in the view configuration modal, which you can open by right-clicking the view item in the sidebar and selecting `Open settings`, or visiting `Settings` -> `View` -> `View Name`.
By default, all views (except the habit view) have the following settings:
### Basic Settings
* **View Name**: The name displayed for the view (e.g., "Inbox").
* **Icon**: The Lucide icon used for the view in the sidebar.
### General Filters
* **Hide Completed and Abandoned Tasks**: Toggle to hide tasks marked as completed (`x`) or abandoned (`-`).
* **Filter Blanks**: Toggle to hide tasks with no content.
### Sort Settings
* **Sort By**: Select the field to sort the tasks by.
* **Sort Direction**: Select the direction to sort the tasks.
### Filter Rules
Define specific criteria for tasks to be included in this view:
* **Text Contains**: Filter by specific text within the task content.
* **Tags Include**: Only show tasks that have *all* specified tags (e.g., `#urgent, #work`).
* **Tags Exclude**: Hide tasks that have *any* of the specified tags (e.g., `#waiting, #someday`).
* **Project Is**: Only show tasks belonging to a specific project path (exact match).
* **Priority Is**: Only show tasks with a specific priority level (e.g., `1`, `2`).
* **Status Include**: Only show tasks with specific status markers (e.g., `/`, `>`).
* **Status Exclude**: Hide tasks with specific status markers (e.g., `-`, `x`).
* **Due/Start/Scheduled Date Is**: Filter tasks based on their due, start, or scheduled dates. Accepts specific dates (`YYYY-MM-DD`) or relative terms (`today`, `next week`).
* **Path Includes**: Only show tasks whose file path contains the specified string (e.g., `Meetings/`).
* **Path Excludes**: Hide tasks whose file path contains the specified string (e.g., `Archive/`).
file: ./content/docs/task-view/event-view.mdx
meta: {
"title": "Event View"
}
import { VersionCallout } from "@/components/VersionCallout";
import {
CalendarDays,
GanttChartSquare,
Clock,
ListChecks,
CalendarCheck2,
ChevronLeft,
ChevronRight,
} from "lucide-react";
The Event View provides a calendar-based interface to visualize and interact with your tasks. It allows you to see tasks plotted on different time scales, navigate through dates, and perform actions directly from the calendar.
## Open the event view
1. Open the [Task Genius View](/docs/task-view).
2. Select `Event` nav item in the left sidebar.
3. You will see the tasks grouped by event in the right panel.
## Usage
The Event View offers several ways to look at your tasks:
* **Multiple views:** Switch between different perspectives:
* **Year view:** Get a high-level
overview of the entire year.
* **Month view:** See tasks laid
out across a specific month.
* **Week view:** Focus on the
current or selected week.
* **Day view:** Examine tasks scheduled
for a single day.
* **Agenda view:** View upcoming
tasks in a list format.
* **Navigation:** Easily move through time:
* **Previous**/**Next**
: Navigate to the previous or next year, month, week, or day depending on the
active view.
* **Today:** Quickly jump back
to the current date.
* **View switching:** Use the buttons or dropdown in the header to select your preferred view (`Year`, `Month`, `Week`, `Day`, `Agenda`). Your last used view is remembered.
* **Date display:** The header clearly shows the currently displayed date range, adapting its format based on the active view (e.g., "MMMM YYYY" for Month view, "MMM D - D, YYYY" for Week view).
## Task Display
Tasks are processed and displayed on the calendar as events:
* **Date mapping:** Tasks are primarily placed on the calendar based on their `Due date`. If `Due date` is not available, it will fall back to `Scheduled date` and then `Start date`. Tasks without any of these dates are currently not displayed in the calendar view.
* **All-day events:** By default, tasks are treated as all-day events on their assigned date.
* **Multi-day events:** If a task has both a `Start date` and a `Due date` that are different, it will be displayed spanning across those days (inclusive).
* **Completed tasks:** Completed tasks are visually distinct (e.g., shown in grey).
## Interactions
You can interact with the calendar in various ways:
* **Clicking an event:** Selects the corresponding task, will open the task in the detail side panel.
* **Clicking a day (Month/Week view):**
* Can be configured to open the Quick Capture modal to quickly add a task for that day.
* Can switch the view to the Day view for the selected date (Note: This is not yet implemented).
* **Clicking a month (Year view):** Switches the view to the Month view for the selected month.
* **Right-clicking an event:** Opens a context menu with relevant actions for that task.
* **Completing an event:** A mechanism (like a checkbox on the event, depending on the view) allows marking the task as complete directly from the calendar.
## Settings
You can read more about the settings in the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
Event view has a special setting:
`First day of week`: This setting determines the first day of the week for the calendar. It can be set to any day of the week.
file: ./content/docs/task-view/flag-view.mdx
meta: {
"title": "Flag View"
}
import { VersionCallout } from "@/components/VersionCallout";
import { ListIcon, GitBranchIcon } from "lucide-react";
The Flag View is a built-in view that displays high-priority tasks or tasks tagged with #flagged. It provides a focused perspective on your most important tasks that require attention.
## Open the flag view
1. Open the [Task Genius View](/docs/task-view).
2. Select `Flag` nav item in the left sidebar.
3. You will see the tasks grouped by flag in the right panel.
## Usage
* **Task Display**: Shows tasks that have a priority level of 3 or higher, or tasks that include the #flagged tag.
* **Filtering**:
* **Text Filter**: A search bar in the header allows for quick filtering of displayed tasks by their content (case-insensitive).
* **Rule-Based Filtering**: Applies predefined filter rules ([see settings](#settings)) to determine which tasks are initially loaded into the view.
* **Priority Filtering**: By default, only shows tasks with priority level 3+ or the #flagged tag.
* **View Modes**:
* **List View** (): Displays tasks as a flat list.
* **Tree View** (): Displays tasks hierarchically, showing parent-child relationships.
* **Task Count**: The header displays the current number of flagged tasks visible after applying filters.
* **Sorting**: Tasks are automatically sorted based on the following order:
1. Completion status (incomplete tasks first).
2. Priority (higher priority first).
3. Due Date (earlier dates first).
4. Task content (alphabetical).
* **Interactions**:
* **Selection**: Click on a task to select it (used for detail views or actions).
* **Completion**: Mark tasks as complete directly within the view.
* **Context Menu**: Right-click on a task to open a context menu for more actions.
* **Lazy Loading**: For performance with large numbers of tasks, the view loads tasks in batches as you scroll down.
## Settings
You can read more about the settings in the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
file: ./content/docs/task-view/forecast-view.mdx
meta: {
"title": "Forecast View"
}
import { VersionCallout } from "@/components/VersionCallout";
import {
ListIcon,
GitBranchIcon,
SidebarIcon,
XIcon,
ChevronDownIcon,
ChevronRightIcon,
} from "lucide-react"; // Assuming Icon component is available
The Forecast View provides a calendar-based perspective on your tasks, showing items with upcoming scheduled or due dates.
## Open the forecast view
1. Open the [Task Genius View](/docs/task-view).
2. Select `Forecast` in the sidebar.
3. The Forecast View will load, displaying the calendar, task stats, upcoming tasks, and the main task list.
## Usage
### Header Bar
The header bar at the top of the Task Panel displays key information and controls:
* **Title:** Shows "Forecast".
* **Task & Project Count:** Displays the total number of tasks loaded and the number of unique projects they belong to (e.g., "15 tasks, 3 projects").
* **View Toggle:** Switches the Task Panel between List view () and Tree view ().
* **Sidebar Toggle (Mobile):** On mobile devices, a icon appears to show/hide the Left Sidebar.
### Left Sidebar
The left sidebar contains navigation and overview components:
#### Stats Bar
Located above the calendar, this bar shows counts for tasks categorized by their relevant date (Scheduled or Due):
* **Past Due:** Count of tasks whose relevant date is before today.
* **Today:** Count of tasks whose relevant date is today.
* **Future:** Count of tasks whose relevant date is after today.
Clicking on any of these stats will filter the Task Panel to show only tasks in that category. Click again to remove the filter.
#### Calendar Component
Displays a monthly calendar.
* Days with tasks are marked.
* Clicking a date selects it, updating the "Coming Up" section and the Task Panel to show tasks relevant to that date and beyond.
* The current date is highlighted.
#### Coming Up Component
Below the calendar, this section lists tasks with relevant dates occurring in the 15 days *after* the date currently selected in the calendar.
* Each entry shows the day of the week, date (e.g., "Mon, Jan 1"), and the number of tasks for that day.
* Clicking an entry selects that date in the calendar.
* On mobile, a close button () is available to hide the sidebar.
### Task Panel
The main panel on the right displays the tasks organized by date.
#### Date Sections
Tasks are grouped into collapsible sections based on their relevant date:
* **Past Due:** Contains all tasks with a relevant date before today. This section appears first if the selected date is today or in the future.
* **Selected Date Section:** Shows tasks for the date selected in the calendar. The title format depends on the selected date relative to today (e.g., "Today — January 1, 2024", "Tomorrow, Tuesday, January 2, 2024", "Wednesday, January 3, 2024").
* **Future Date Sections:** Shows tasks for dates after the selected date. Sections for the next 7 days after the selected date are expanded by default.
Each section header displays:
* An expand/collapse toggle ( / ).
* The section title (e.g., "Past Due", "Today — ...").
* A badge showing the number of tasks in that section.
#### View Mode
The **View Toggle** button in the Header Bar switches this panel between:
* **List View ():** Shows tasks as a flat list within each date section.
* **Tree View ():** Organizes tasks hierarchically based on parent tasks or project structure (if applicable).
#### Task Sorting
Within each date section, tasks are automatically sorted first by **Priority** (highest to lowest) and then by their **Relevant Date** (earliest to latest).
#### Relevant Date Logic
The view uses the `scheduledDate` of a task if available. If a task has no `scheduledDate`, it uses the `dueDate`. Tasks without either date are not displayed in the Forecast View.
## Settings
You can read more about the settings in the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
### First Day of Week
You can set the first day of week in
file: ./content/docs/task-view/habit-view.mdx
meta: {
"title": "Habit View"
}
import { VersionCallout } from "@/components/VersionCallout";
The Habit View provides a visual interface to track your progress on the habits you've defined in Task Genius. It leverages the data you record in your daily notes' Frontmatter.
## Open the Habit View
1. Open the [Task Genius View](/docs/task-view).
2. Select the `Habit` nav item in the left sidebar.
3. The Habit View will load, displaying your tracked habit data.
## Usage
The Habit View typically presents your habit data in a calendar-like format, often referred to as a heatmap or streaks view. This allows you to quickly see your consistency over time.
The view generally consists of:
1. **Habit Grid/Calendar:** The main area showing days and whether each habit was completed according to its definition. Colors, icons, or other visual cues are used to represent the status (e.g., completed, missed, partially completed, value recorded).
2. **Summary/Statistics (If applicable):** May include information like current streaks, completion rates, or other relevant statistics.
You can press checkbox or icon button to toggle the habit status.
### Tooltip
You can hover over the habit heatmap to see the tooltip with the habit status and the value recorded.
### Configuring Habits
The Habit View is for *visualizing* your progress based on the habits you have already set up.
Open Habit Settings
To **define**, **add**, or **modify** habits (e.g., change their name, icon, type, properties, or completion conditions), you must use the Task Genius settings:
1. Open Task Genius settings.
2. Navigate to the **Habit** settings tab.
3. Configure your habits there.
For comprehensive instructions on how to define and manage your habits, please refer to the main **[Habit Tracking Setup](/docs/habit)** documentation.
file: ./content/docs/task-view/inbox-view.mdx
meta: {
"title": "Inbox View"
}
import { VersionCallout } from "@/components/VersionCallout";
import { ListIcon, GitBranchIcon } from "lucide-react";
The Inbox View is a built-in view that displays tasks based on specific criteria, acting as a central place to process incoming or unfiltered tasks. It utilizes a flexible content component that supports various display and filtering options.
## Open the inbox view
1. Open the [Task Genius View](/docs/task-view).
2. Select `Inbox` nav item in the left sidebar.
3. You will see the tasks grouped by inbox in the right panel.
## Usage
* **Task Display**: Shows tasks that match its configured filter rules. By default, it might show tasks without project tags.
* **Filtering**:
* **Text Filter**: A search bar in the header allows for quick filtering of displayed tasks by their content (case-insensitive).
* **Rule-Based Filtering**: Applies predefined filter rules ([see settings](#settings)) to determine which tasks are initially loaded into the view.
* **View Modes**:
* **List View** (): Displays tasks as a flat list.
* **Tree View** (): Displays tasks hierarchically, showing parent-child relationships. You can toggle between these modes using the list/branch icon in the header.
* **Task Count**: The header displays the current number of tasks visible after applying filters.
* **Sorting**: Tasks are automatically sorted based on the following order:
1. Completion status (incomplete tasks first).
2. Priority (higher priority first).
3. Due Date (earlier dates first).
4. Task content (alphabetical).
* **Interactions**:
* **Selection**: Click on a task to select it (used for detail views or actions).
* **Completion**: Mark tasks as complete directly within the view.
* **Context Menu**: Right-click on a task to open a context menu for more actions.
* **Lazy Loading**: For performance with large numbers of tasks, the view loads tasks in batches as you scroll down.
## Settings
You can read more about the settings in the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
file: ./content/docs/task-view/index.mdx
meta: {
"title": "View"
}
import { VersionCallout } from "@/components/VersionCallout";
The Task Genius View provides a powerful, centralized dashboard to manage all your tasks across your entire Obsidian vault.
## Quick Access
Open View Settings
## Architecture
Task Genius uses the modern **Dataflow Architecture** for optimal performance and flexibility:
* **Event-driven System**: Real-time updates across all views
* **Multi-source Support**: Seamlessly integrates file tasks, ICS calendar events, and file-level tasks
* **Smart Caching**: Fast startup with persisted state and incremental updates
* **Worker Processing**: Parallel processing for large vaults
* **Bases Compatible**: All views can be used within Obsidian Bases for enhanced data visualization
The system automatically indexes your tasks and keeps them synchronized across all views.
## Opening the View
Access the view using one of these methods:
* Click the dedicated **Ribbon Icon** (if enabled in settings).
* Run the command `Task Genius: Open Task Genius view` from the Obsidian command palette (`Ctrl/Cmd + P`).
## Interface Overview
The view typically consists of:
* **Left Panel/Sidebar**: Navigation controls to switch between different views.
* **Main Panel**: Displays the [list of tasks](/docs/task-view/list-item) based on the current mode and filters. (You can filter by tags, projects, status, etc.)
* **Right Panel (Details Panel)**: Shows detailed information and allows editing of the currently selected task.
## Views
The Task Genius View offers several views to organize and visualize your tasks:
## Interacting with Tasks
Within the view, you can:
* **View/Edit Details**: Click on a task in the main panel to see its full description, due date, priority, notes, source file link, etc., in the right details panel. You can often edit these details directly.
* **Change Status**: Click the task marker (e.g., `[ ]`) directly in the task list to cycle its status or mark it complete.
* **Sort & Filter**: Use controls within the view to sort tasks (by priority, due date, etc.) and apply filters (by tag, status, date range, etc.).
* **Context Menu**: Right-click on a task in the list to access relevant actions (e.g., set priority, set due date, move task, go to source note).
## Task Indexing
The Dataflow architecture maintains a high-performance index of all tasks:
### Automatic Updates
* **Real-time Monitoring**: File changes trigger instant updates
* **Event-driven Sync**: All views stay synchronized automatically
* **Background Processing**: Workers handle large operations without blocking
### Data Sources
* **File Tasks**: Regular tasks from Markdown and Canvas files
* **ICS Events**: External calendar events displayed as tasks
* **File-level Tasks**: Entire files recognized as tasks based on metadata
* **Bases Integration**: Native Obsidian file indexing for notes as tasks ([Learn more](/docs/bases-support))
### Manual Controls
If needed, you can manually refresh the index:
* `Task Genius: Refresh task index` - Quick refresh
* `Task Genius: Force reindex all tasks` - Complete rebuild
Learn more in the [Task Indexing](/docs/task-view/indexer) documentation.
file: ./content/docs/task-view/indexer.mdx
meta: {
"title": "Indexer"
}
import { VersionCallout } from "@/components/VersionCallout";
Task Genius uses the modern **Dataflow Architecture** to efficiently index and manage tasks from multiple sources. This event-driven system provides real-time updates, smart caching, and exceptional performance.
## Quick Configuration
Open Index Settings
## How it Works
The Dataflow architecture orchestrates multiple components for optimal performance:
### Core Components
1. **Orchestrator**: Central coordinator managing all data sources and events
2. **Data Sources**:
* **ObsidianSource**: Monitors file changes in your vault
* **IcsSource**: Integrates external calendar events
* **FileSource**: Recognizes entire files as tasks
3. **Repository**: Maintains the task index and handles queries
4. **Storage**: Multi-tier caching system for instant startup
5. **Workers**: Background processing for large operations
### Processing Flow
1. **File Monitoring**: ObsidianSource watches for changes (create, modify, delete)
2. **Smart Caching**: Repository checks cache validity using content hashing
3. **Parallel Processing**:
* WorkerOrchestrator distributes parsing to Web Workers
* Multiple files processed simultaneously
* Automatic fallback to main thread if needed
4. **Event Broadcasting**: Changes trigger `task-genius:task-cache-updated` events
5. **View Synchronization**: All views update automatically via event subscription
### Performance Features
* **Snapshot Loading**: \~100ms startup for 1000+ tasks
* **Incremental Updates**: Only changed files reprocessed
* **Content Hashing**: Detect actual changes vs. metadata updates
* **Loop Prevention**: Sequence-based event tracking prevents infinite updates
B[ObsidianSource]
K[Calendar] -- Sync --> L[IcsSource]
M[File Tasks] -- Recognize --> N[FileSource]
end
subgraph "Dataflow Core"
B -- FILE_UPDATED --> O[Orchestrator]
L -- ICS_EVENTS_UPDATED --> O
N -- FILE_TASK_UPDATED --> O
O -- Process --> P[Repository]
P -- Query --> Q[Storage Cache]
Q -- Hit/Miss --> R{Cache Status}
R -- Miss --> S[WorkerOrchestrator]
S -- Parse --> T[Web Workers]
T -- Results --> P
R -- Hit --> U[Cached Data]
U --> P
end
subgraph "Views"
P -- TASK_CACHE_UPDATED --> V[All Views]
V --> W[UI Updates]
end
`}
/>
### Data Sources
The system integrates multiple data sources seamlessly:
* **File Tasks**: Regular tasks from Markdown and Canvas files
* **ICS Events**: External calendar events displayed as tasks
* **File-level Tasks**: Entire files treated as tasks based on metadata
### Troubleshooting
If the index seems outdated:
* Run `Task Genius: Force reindex all tasks` to rebuild completely
* Use `Task Genius: Refresh task index` for a quick refresh
* Check console for any error messages
## Managing the Indexer
### Disabling
Disable indexing in Settings → Task Genius → Index → "Enable Indexing"
### Performance Tuning
* **Worker Count**: Adjust based on vault size (Settings → Index)
* **Cache Duration**: Configure persistence time
* **Batch Size**: Control processing chunks
## Configuration
Customize indexing behavior to match your workflow:
### Metadata Format
Choose how to parse task metadata:
* **Tasks**: Emoji format (`🛫 2025-01-01`, `⏫`, `🔁 every week`)
* **Dataview**: Inline fields (`[due:: 2025-01-01]`, `[priority:: high]`)
The system automatically falls back to the other format when needed.
### Daily Notes Integration
Automatically assign dates to tasks in daily notes:
* **Enable**: Extract dates from daily note file paths
* **Path**: Daily notes folder (e.g., `dailies`, `journal/daily`)
* **Format**: Date pattern in filenames (`yyyy-MM-dd`, `dd-MM-yyyy`)
* **Assign As**: Target field for extracted date (`due`, `start`, `scheduled`)
### Heading Filters
Control which tasks are indexed based on their headings:
* **Ignore Under**: Exclude tasks under specific headings (`## Archive`, `## Done`)
* **Focus On**: Only index tasks under specified headings (`## Project`, `## Inbox`)
Enter headings separated by commas. Focus takes priority over ignore.
file: ./content/docs/task-view/inline-editor.mdx
meta: {
"title": "Inline Editor"
}
import { VersionCallout } from "@/components/VersionCallout";
The Inline Editor is a powerful component that enables direct editing of task content and metadata within the task view. It provides seamless in-place editing capabilities without requiring separate sidebar or dialogs.
## Overview
The Inline Editor component allows users to edit task properties directly within the task list view. It supports both content editing and metadata field editing with intelligent auto-completion.
## Features
### Content Editing
The editor supports two modes for editing task content (Currently, Task Genius is not support Textarea editor mode):
* **Embedded Markdown Editor**: Full-featured markdown editor with syntax highlighting and live preview.
* ~~**Textarea Editor**: Lightweight text input with auto-resize functionality~~
### Metadata Editing
Supports editing of all task metadata fields:
* **Project**: Project assignment with autocomplete
* **Tags**: Tag management with comma-separated input and autocomplete
* **Context**: Context assignment with autocomplete
* **Dates**: Due date, start date, and scheduled date with date picker
* **Priority**: Priority levels (1-5) with dropdown selection
* **Recurrence**: Recurrence rules with text input
Using `Enter` to save and exit the editor.
## Keyboard Shortcuts
| Shortcut | Action |
| -------- | ---------------------------------------------------------------------------------- |
| `Enter` | Save and exit (content: embedded editor handles this, metadata: saves immediately) |
| `Escape` | Cancel editing and revert changes |
## Event Handling
### Content Events
* **Blur**: Automatically saves and exits content editing
* **Keydown**: Handles Enter/Escape key combinations
### Metadata Events
* **Blur**: Saves and exits metadata editing
* **Change**: Immediate save for select elements (priority)
## Auto-completion
The editor provides intelligent auto-completion for:
* **Projects**: Suggests existing project names from the vault
* **Tags**: Suggests existing tags with # prefix support
* **Contexts**: Suggests existing context values
## Settings
You can configure the inline editor in the Task Genius settings.
file: ./content/docs/task-view/list-item.mdx
meta: {
"title": "List Item"
}
import { VersionCallout } from "@/components/VersionCallout";
import { ListItem } from "@/components/ListItem";
List item is the basic unit of the task view. It is a single task that is displayed in the list view.
## Task List Item
This component is responsible for rendering a single task item within the task list view. It displays task details like content, dates, priority, tags, and handles user interactions.
Contains the following information:
* Task checkbox
* Task content
* Task dates
* Task priority
* Task tags
* Task project
### Rendering Principles
* **Task Checkbox**: Displays the task's completion status (`Status`). Clicking it triggers the completion logic. The entire item gets a `task-completed` class if the task is marked as done.
* **Task Content**: Renders the `Original Markdown` using Task Genius's Markdown renderer that extends Obsidian's Markdown renderer, preserving formatting and links.
* **Task Dates**:
* **Incomplete Tasks**: Shows Due, Scheduled, and Start dates if available. Due dates are styled differently if they are overdue, due today, or due tomorrow. Recurrence rules are also shown if present.
* **Completed Tasks**: Shows Completion and Created dates if available.
* **Relative Time**: Dates can be displayed using relative time (e.g., "in 2 days", "yesterday") based on the `Use Relative Time` setting. (Available in Task Genius [8.6.0+](/changelog/2025-05-04-desktop-v8.6.0))
* **Task Priority**: If `Priority` is set (1, 2, or 3), an indicator (eg, `!`, `!!`, `!!!`) is displayed, styled with a corresponding CSS class (`priority-1`, `priority-2`, `priority-3`).
* **Task Tags**: If `Tags` exist, each tag is displayed, prefixed with `#`.
* **Task Project**: If `Project` exists and the current view is not the project view (`viewMode !== 'projects'`), the project name (typically the last part of the path) is displayed.
file: ./content/docs/task-view/matrix-view.mdx
meta: {
"title": "Matrix View (Eisenhower Matrix)"
}
import { VersionCallout } from "@/components/VersionCallout";
import {
Filter,
Grid3X3,
MousePointerClick,
ArrowUpDown,
Eye,
EyeOff,
PlusIcon,
XIcon,
} from "lucide-react";
The Matrix View provides an Eisenhower Matrix (Four Quadrants) interface for organizing and managing your tasks based on urgency and importance. This view helps you prioritize tasks effectively by categorizing them into four distinct quadrants.
## Open the Matrix View
1. Open the [Task Genius View](/docs/task-view).
2. Select the `Matrix` navigation item in the left sidebar.
3. You will see your tasks organized into four quadrants in the right panel.
## Usage
The Matrix View displays tasks in a 2x2 grid based on the Eisenhower Matrix methodology:
### The Four Quadrants
* **🔺 Urgent & Important (Do First):** Crisis & emergencies that require immediate attention
* **⏫ Not Urgent & Important (Schedule):** Planning & development activities that are important but not time-sensitive
* **🔼 Urgent & Not Important (Delegate):** Interruptions & distractions that are urgent but not crucial
* **🔽 Not Urgent & Not Important (Eliminate):** Time wasters that should be minimized or eliminated
### Task Categorization
Tasks are automatically categorized into quadrants based on:
#### Tag-Based Classification (Default)
* **Urgency:** Determined by `#urgent` tag, high priority emojis (🔺⏫), or due dates within the configured threshold
* **Importance:** Determined by `#important` tag, priority emojis (🔺⏫🔼), or important keywords (goal, project, milestone, strategic)
#### Priority-Based Classification (Optional)
* **Urgency:** Tasks with priority level ≥ 4 (configurable threshold)
* **Importance:** Tasks with priority level ≥ 3 (configurable threshold)
### Interactions
#### Drag and Drop
* **Move tasks between quadrants** by clicking and dragging them
* Dropping a task into a new quadrant automatically updates the task's tags and priority
* Visual feedback shows successful task updates
#### Task Actions
* **Click task:** Selects the task and opens its details in the sidebar
* **Right-click task:** Opens a context menu with relevant actions
* **Status updates:** Tasks can be marked as complete directly from the matrix
#### Sorting
* **Sort dropdown:** Located in the header, allows sorting tasks within each quadrant
* Available sort options:
* Priority (High to Low / Low to High)
* Due Date (Earliest First / Latest First)
* Created Date (Newest First / Oldest First)
### Filtering
The Matrix View includes advanced filtering capabilities:
1. Click the **Add filter** button to open the filter dropdown
2. Select a **category** to filter by (e.g., `Tag`, `Priority`, `Project`, `Context`)
3. Choose the specific **value** within that category
4. Active filters are displayed as removable "pills" above the matrix (remove via )
5. Multiple filters can be applied - tasks must match **all** active filters to be displayed
6. Click **Clear all** to remove all active filters at once
Available filter categories include:
* Status
* Tag
* Project
* Context
* Priority
* Completed (Yes/No)
* File Path
### Column Management
* **Hide empty columns:** / Option to hide quadrants that contain no tasks
* **Dynamic updates:** Quadrants automatically update when tasks are added, removed, or modified
### Task Updates
When moving tasks between quadrants:
1. **Automatic tag updates:** Relevant `#urgent` and `#important` tags are added or removed
2. **Priority adjustment:** Task priority is updated based on the target quadrant:
* Urgent & Important: Priority 5 (Highest)
* Not Urgent & Important: Priority 4 (High)
* Urgent & Not Important: Priority 3 (Medium)
* Not Urgent & Not Important: Priority 2 (Low)
3. **Metadata tracking:** Quadrant information is stored in task metadata for consistency
4. **Visual feedback:** Success or error messages appear after task updates
### Performance Optimizations
* **Selective refresh:** Only updates quadrants with changed tasks
* **Mobile optimization:** Enhanced touch interactions with appropriate delays and thresholds
* **Efficient rendering:** Virtual scrolling and optimized DOM updates for large task lists
## Configuration
### Quadrant Settings
The Matrix View can be configured through view-specific settings:
* **Urgent Tag:** Custom tag for identifying urgent tasks (default: `#urgent`)
* **Important Tag:** Custom tag for identifying important tasks (default: `#important`)
* **Urgent Threshold Days:** Number of days before due date to consider a task urgent (default: 3)
* **Classification Mode:** Choose between tag-based or priority-based classification
* **Priority Thresholds:** Configure priority levels for urgent/important classification
### Advanced Options
* **Use Priority for Classification:** Switch from tag-based to priority-based categorization
* **Urgent Priority Threshold:** Priority level threshold for urgent tasks (default: 4)
* **Important Priority Threshold:** Priority level threshold for important tasks (default: 3)
* **Hide Empty Columns:** Automatically hide quadrants without tasks
## Best Practices
1. **Focus on incomplete tasks:** Filter out completed tasks to simplify the view
2. **Consistent Tagging:** Use `#urgent` and `#important` tags consistently across your tasks
3. **Regular Review:** Regularly review and move tasks between quadrants as priorities change
4. **Focus on Quadrant 2:** Spend more time on "Not Urgent & Important" tasks for long-term success
5. **Minimize Quadrant 4:** Eliminate or reduce "Not Urgent & Not Important" tasks
6. **Due Date Management:** Set appropriate due dates to help with automatic urgency classification
## Settings
You can read more about view settings on the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
### Specific Settings
* **Hide Empty Columns:** Automatically hide quadrants that contain no tasks
* **Sort Option:** Default sorting method for tasks within each quadrant
* **Classification Mode:** Choose between tag-based or priority-based task categorization
file: ./content/docs/task-view/plan-view.mdx
meta: {
"title": "Plan View (Gantt)"
}
import { VersionCallout } from "@/components/VersionCallout";
import {
Filter,
GanttChartSquare,
ZoomIn,
ZoomOut,
MousePointerClick,
CalendarSearch,
Pin,
PinOff,
} from "lucide-react";
The Plan View provides a timeline-based Gantt chart interface for visualizing and managing your tasks and their dependencies. It allows you to view task durations, start/end dates, and navigate through the timeline.
## Open the Plan View
1. Open the [Task Genius View](/docs/task-view).
2. Select the `Plan` navigation item in the left sidebar.
3. You will see the tasks displayed as a Gantt chart in the right panel.
## Usage
The Plan View displays tasks based on a horizontal timeline:
* **Timeline:** Shows dates, automatically adjusting the display granularity (Day, Week, Month, Year) based on the zoom level.
* **Task Bars:** Represent tasks with both start and end dates.
* **Milestones:** Represent tasks with only a due date or identical start and end dates.
* **Filter Area:** Located at the top of the view, allowing you to filter displayed tasks based on various criteria. Read more about the filter in the [Advanced Filter](/docs/task-view/filter/advanced-filter) page.
### Task Display
Tasks are processed and displayed on the Gantt chart based on their date properties:
* **Date Mapping:**
* The **start** position of a task bar is based on `Start date` or `Scheduled date`.
* The **end** position of a task bar is based on `Due date`.
* If only `Due date` is present, or if `Start date` is the same as `Due date`, the task is displayed as a **Milestone** (diamond shape).
* Tasks without valid date information will not be displayed on the Gantt chart.
* **Task Sorting:** Tasks are sorted by default based on their start date (or due date).
* **Task Labels:** Task content (supports Markdown rendering) is displayed next to the task bar or milestone.
### Interactions
You can interact with the Gantt chart in several ways:
* **Click Task Bar/Milestone:** Selects the corresponding task and opens its details in the sidebar.
* **Right-click Task Bar/Milestone:** Opens a context menu with relevant actions for that task.
* **Click Offscreen Indicator:** / If a task is outside the currently visible area, indicators appear on the left/right edges of the view. Clicking an indicator scrolls the view to that task's position.
* **Scroll to Date:** Use the "Scroll to Date" button in the filter area to quickly navigate to a specific date.
### Navigation & Zoom
* **Horizontal Scrolling:** Use the scrollbar or touchpad/mouse wheel to scroll the timeline horizontally to view tasks in different time periods.
* **Zooming:** / Hold the `Ctrl` key and scroll the mouse wheel to zoom the timeline.
* Zooming in increases the timeline granularity (e.g., from Month view to Week or Day view).
* Zooming out decreases the timeline granularity (e.g., from Day view to Week, Month, or Year view).
* Zooming centers on the time point under the mouse cursor.
## Settings
You can read more about view settings on the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
file: ./content/docs/task-view/project-view.mdx
meta: {
"title": "Project View"
}
import { VersionCallout } from "@/components/VersionCallout";
Project view is a view that allows you to view your tasks by their project. Inherits from the [Two Column View](/docs/task-view/custom-view/two-column-view).
## Open the project view
1. Open the [Task Genius View](/docs/task-view).
2. Select `Project` nav item in the left sidebar.
3. You will see the tasks grouped by project in the right panel.
## Usage
1. Add `#project/xx` to your tasks you want to group by project.
2. Open the [Task Genius View](/docs/task-view).
3. Select `Project` nav item in the left sidebar.
4. You will see the tasks grouped by project in the right panel.
### Multi-select
Read more about the multi-select in the [Two Column View](/docs/task-view/custom-view/two-column-view#multi-select) page.
## Settings
You can read more about the settings in the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
file: ./content/docs/task-view/review-view.mdx
meta: {
"title": "Review View"
}
import { VersionCallout } from "@/components/VersionCallout";
import { FolderCheckIcon, FolderIcon, SidebarIcon } from "lucide-react";
The Review View helps you systematically review tasks on a project-by-project basis according to a defined schedule. It allows you to configure review frequencies for each project and keeps track of when each project was last reviewed.
## Open the review view
1. Open the [Task Genius View](/docs/task-view).
2. Select `Review` nav item in the left sidebar.
3. You will see the tasks grouped by project in the right panel.
## Usage
The Review View features a two-column layout:
1. **Project Sidebar (Left):** Lists all projects containing tasks.
2. **Task Review Area (Right):** Displays tasks for the selected project and provides review controls.
On mobile devices, the Project Sidebar is initially hidden and can be toggled using the .
### Project Sidebar
The sidebar lists your projects, grouped into two sections:
* **Configured for Review:** Projects for which you have set a review schedule. These projects have a . Projects due for review according to their schedule are highlighted.
* **Not Configured:** Projects without a review schedule. These projects have a .
Clicking on a project name in the sidebar selects it for review in the right-hand area.
### Task Review Area
When you select a project, this area displays its details and tasks.
#### Header
The header shows:
* **Project Title:** The name of the selected project.
* **Review Information:**
* If configured: The review frequency (e.g., "Review every weekly") and the date it was last reviewed (e.g., "Last reviewed: 1/1/2024"). Clicking the frequency text opens the configuration modal.
* If not configured: A message indicating "No review schedule configured for this project".
* **Action Button:**
* If configured: A "**Mark as Reviewed**" button.
* If not configured: A "**Configure Review Schedule**" button.
#### Configuring the Review Schedule
You can configure the review schedule for a project by:
1. Clicking the "**Configure Review Schedule**" button (for unconfigured projects).
2. Clicking the frequency text in the header (for already configured projects).
This opens a modal where you can set:
* **Review Frequency:** Choose from predefined options (daily, weekly, every 2 weeks, monthly, quarterly, every 6 months, yearly) or select "Custom..." to define your own (e.g., "every 10 days").
* The modal also displays when the project was last reviewed.
#### Task List & Filtering
By default, when you select a project that has been reviewed before, the task list is filtered to show only:
* Tasks created *after* the last review date.
* Tasks that existed during the last review but were *not completed* then and are *still not completed*.
* Tasks that were *not part of the last review* (e.g., older tasks added to the project later).
Completed tasks from the previous review session are hidden by default to focus your attention on what's new or still pending.
* A message like "Showing new and in-progress tasks only. X completed tasks from previous reviews are hidden." will appear below the header.
* You can click "**Show all tasks**" to disable this filter and view every task in the project, including previously reviewed and completed ones.
* Click "**Show only new and in-progress tasks**" to re-enable the default filter.
If a project has never been reviewed, all its tasks are shown initially.
#### Marking a Project as Reviewed
Clicking the "**Mark as Reviewed**" button performs two actions:
1. Updates the "Last Reviewed" timestamp for the project to the current date and time.
2. Records the IDs of all tasks currently associated with the project (regardless of whether they are visible due to filtering). This list is used for filtering in subsequent reviews.
After marking as reviewed, the task list will refresh based on the default filtering logic (hiding completed tasks from the review you just finished).
## Settings
You can read more about the settings in the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
file: ./content/docs/task-view/status-view.mdx
meta: {
"title": "Status View (Kanban)"
}
import { VersionCallout } from "@/components/VersionCallout";
import {
FolderCheckIcon,
FolderIcon,
SidebarIcon,
FilterIcon,
PlusIcon,
XIcon,
} from "lucide-react";
The Status View displays your tasks in a Kanban board format, organized into columns based on their status. This allows for a visual workflow management where you can easily track task progress.
## Open the status view
1. Open the [Task Genius View](/docs/task-view).
2. Select `Status` nav item in the left sidebar.
3. You will see the tasks grouped by status in the right panel.
## Usage
### Columns
* Each column represents a specific task status defined in your settings (e.g., "Todo", "In Progress", "Done"). Based on the status of task itself.
* The order of the columns follows the `taskStatusCycle` setting, typically grouping standard statuses, then custom statuses, and finally completed statuses (marked with 'x').
* Tasks within each column are sorted primarily by priority (highest first) and secondarily by due date (earliest first).
### Drag and Drop
* You can move tasks between columns by clicking and dragging them.
* Dropping a task into a new column will update the task's status to match the status of that column.
* Visual indicators appear during dragging to show where the task will be placed.
### Filtering
Above the Kanban board, filter controls allow you to narrow down the displayed tasks.
1. Click the **Add filter** button to open a dropdown.
2. Select a **category** to filter by (e.g., `Tag`, `Priority`, `Project`).
3. Select the specific **value** within that category (e.g., `#urgent`, `🔺 Highest`, `MyProject`).
4. Available filter categories and options are dynamically generated based on the tasks currently loaded.
5. Active filters are displayed as removable "pills" above the board (via ).
6. You can add multiple filters. Tasks must match **all** active filters to be displayed.
7. Click the **Clear all** button to remove all active filters at once.
8. The filterable criteria include:
* Status
* Tag
* Project
* Context
* Priority (often represented by icons like 🔺, ⏫, 🔼)
* Completed (Yes/No)
* File Path
9. Applying, adding, or removing filters dynamically updates the Kanban board.
### Group by
You can group tasks by status, tag, project, context, priority, completed, and file path.
You can also group tasks by custom status.
### Sort by
You can sort tasks by status, tag, project, context, priority, completed, and file path.
### Hide empty columns
You can hide empty columns by enable `Hide empty columns` in the settings.
## Settings
You can read more about the settings in the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
### Specific settings
`Show Checkbox`: When enabled, displays a checkbox for each task in the kanban view, allowing you to mark tasks as complete directly from the board.
file: ./content/docs/task-view/table-view.mdx
meta: {
"title": "Table View"
}
import { VersionCallout } from "@/components/VersionCallout";
import { ListIcon, GitBranchIcon, ArrowUpDownIcon } from "lucide-react";
The Table View provides a comprehensive tabular interface for viewing, editing, and managing your tasks in Task Genius. It offers powerful features like sorting, filtering, inline editing, and both flat and hierarchical tree views.
## Open the Table View
1. Open the [Task Genius View](/docs/task-view).
2. Select the `Table` nav item in the left sidebar.
3. The Table View will load, displaying your tasks in a structured table format.
## Usage
The Table View presents your tasks in a spreadsheet-like interface with powerful data management capabilities.
The view consists of:
1. **Table Header Bar:** Contains controls for view mode toggle (flat/tree), and column visibility settings.
2. **Table Headers:** Column headers that support sorting (click to sort) and resizing (drag column borders).
3. **Table Body:** The main area displaying task data in rows and columns.
4. **Selection Controls:** Support for single and multi-row selection using click and Ctrl/Cmd+click.
### Available Columns
The table supports various column types that can be shown or hidden:
* **Status:** Task completion status with visual indicators
* **Content:** Task description and details
* **Priority:** Task priority level (High, Medium, Low)
* **Due Date:** When the task is due
* **Start Date:** When the task should start
* **Scheduled Date:** When the task is scheduled
* **Created Date:** When the task was created
* **Completed Date:** When the task was completed
* **Tags:** Associated task tags
* **Project:** Project assignment
* **Context:** Task context
* **Recurrence:** Recurring task settings
* **Estimated Time:** Time estimated to complete
* **Actual Time:** Time actually spent
* **File:** Source file location
### View Modes
#### Flat View
Displays all tasks in a simple list format with each task on its own row. You can click on button to toggle the view mode.
#### Tree View
Organizes tasks hierarchically, showing parent-child relationships and allowing you to expand/collapse task groups. You can click on button to toggle the view mode.
### Sorting and Filtering
* **Click column headers** or button to sort by that column. You can click again to reverse sort order.
* **Visual sort indicators** show current sort field and direction.
* Tasks are automatically filtered and sorted based on your current criteria
### Inline Editing
When inline editing is enabled:
* **Double-click any cell** to start editing
* **Press Enter** to save changes
* **Press Escape** to cancel editing
* **Date fields** show date pickers for easy selection
* **Priority fields** provide dropdown selection
* **Status fields** provide dropdown selection
* **Tag fields** support comma-separated values
### Row Selection
* **Single-click** to select a row
* **Ctrl/Cmd+click** for multi-selection
* **Right-click** for context menu options
### Virtual Scrolling
For large task lists, the table uses virtual scrolling to maintain performance by only rendering visible rows.
### Column Management
Use the column visibility controls in the header bar to:
* **Show/hide columns** based on your needs
* **Resize columns** by dragging column borders
* Settings are automatically saved
### Keyboard Shortcuts
* **Escape:** Cancel current cell editing
* **Tab:** Move to next cell
* **Shift+Tab:** Move to previous cell
* **Arrow keys:** Navigate between cells (when editing)
* **Enter:** Confirm cell editing
## Settings
You can read more about the settings in the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
file: ./content/docs/task-view/tag-view.mdx
meta: {
"title": "Tag View"
}
import { VersionCallout } from "@/components/VersionCallout";
Tag view is a view that allows you to view your tasks by their tag. Inherits from the [Two Column View](/docs/task-view/custom-view/two-column-view).
## Open the tag view
1. Open the [Task Genius View](/docs/task-view).
2. Select `Tag` nav item in the left sidebar.
3. You will see the tasks grouped by tag in the right panel.
## Usage
1. Add `#tag` to your tasks you want to group by tag.
2. Open the [Task Genius View](/docs/task-view).
3. Select `Tag` nav item in the left sidebar.
4. You will see the tasks grouped by tag in the right panel.
### Multi-select
Read more about the multi-select in the [Two Column View](/docs/task-view/custom-view/two-column-view#multi-select) page.
## Settings
You can read more about the settings in the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
file: ./content/docs/task-view/timeline-sidebar-view.mdx
meta: {
"title": "Timeline Sidebar View"
}
import { VersionCallout } from "@/components/VersionCallout";
import {
Calendar,
CalendarClock,
RefreshCw,
Focus,
ExternalLink,
Clock,
CheckSquare,
Plus,
MoreHorizontal,
} from "lucide-react";
The Timeline Sidebar View provides a chronological timeline interface for viewing and managing your tasks based on their dates. It displays tasks in a time-ordered format, making it easy to see what's happening when and track your schedule at a glance.
## Open the Timeline Sidebar View
Open Timeline Settings
The Timeline Sidebar View can be opened as a dedicated sidebar panel:
1. Use the command palette (`Ctrl/Cmd + P`) and search for "Timeline"
2. Or use the ribbon icon if available
3. The timeline will appear as a sidebar panel showing your tasks chronologically
## Usage
The Timeline Sidebar View presents your tasks in a chronological timeline format with the following components:
### Timeline Display
* **Date Groups:** Tasks are grouped by date (Today, Yesterday, Tomorrow, or specific dates)
* **Chronological Order:** Events are sorted by time, with the most recent events first
* **Time Stamps:** Each event shows the specific time when it's scheduled or due
* **Visual Indicators:** Today's events are highlighted with special styling
### Event Types
The timeline displays various task-related events:
* **Due Date Events:** Tasks with due dates
* **Scheduled Events:** Tasks with scheduled dates
* **Start Date Events:** Tasks with start dates
* **Completion Events:** Tasks with completion dates (if enabled in settings)
### Header Controls
The timeline header provides several navigation and control options:
#### Navigation Controls
* **Today Button:** Quickly scroll to today's events
* **Refresh Button:** Manually refresh the timeline data
* **Focus Mode:** Toggle focus mode to show only today's events
### Task Interactions
#### Task Management
* **Task Checkboxes:** Click to mark tasks as complete/incomplete
* **Task Navigation:** Click on any task to navigate to its location in your vault
* **Go to Task:** Use the action button to jump to the task's file
#### Visual States
* **Completed Tasks:** Visually distinguished with different styling
* **Today's Events:** Highlighted with special "is-today" styling
* **Task Status:** Shows current task status and allows status changes
### Quick Capture
The timeline includes a built-in quick capture feature at the bottom:
#### Quick Input Area
* **Markdown Editor:** Built-in editor with markdown support
* **Placeholder Text:** "What do you want to do today?"
* **Target Information:** Shows where captured tasks will be saved
#### Capture Actions
* **Quick Capture:** Save the task using current quick capture settings
* **More Options:** Open the full Quick Capture modal with advanced options
#### Keyboard Shortcuts
* **Ctrl/Cmd + Enter:** Submit the quick capture
* **Escape:** Clear the input field
* **Auto-focus:** Input field automatically receives focus after capture
### Date Grouping
Tasks are intelligently grouped by date with relative time indicators:
* **Today:** Current day's events with "Today" label
* **Yesterday/Tomorrow:** Recent days with relative labels
* **Specific Dates:** Other dates shown in "MMM DD, YYYY" format
* **Relative Time:** Shows "X days ago" or "in X days" for context
## Features
### Smart Filtering
The timeline automatically filters content based on settings:
* **Completed Tasks:** Option to show/hide completed tasks
* **Date-based Display:** Only shows tasks with relevant date information
### Auto-scrolling
* **Today Focus:** Automatically scrolls to today's events when opened
* **Smooth Scrolling:** Animated scrolling for better user experience
* **Scroll Memory:** Maintains scroll position during updates
## Configuration
### Timeline Settings
The timeline behavior can be configured through plugin settings:
* **Show Completed Tasks:** Choose whether to display completed tasks in the timeline
* **Date Range:** Configure how far back/forward to show events
* **Auto-scroll:** Enable/disable automatic scrolling to today
### Quick Capture Settings
The integrated quick capture uses the global quick capture settings:
* **Target Type:** Daily notes or specific file
* **Target File:** Specific file for capturing tasks
* **Target Heading:** Specific heading within the target file
* **Daily Note Settings:** Format and folder for daily notes
### Display Options
* **Time Format:** 24-hour or 12-hour time display
* **Date Format:** Customize date display format
* **Relative Time:** Show relative time indicators
* **Visual Themes:** Timeline appearance customization
## Best Practices
1. **Regular Review:** Use the timeline for daily and weekly planning reviews
2. **Quick Capture:** Leverage the integrated quick capture for rapid task entry
3. **Date Management:** Set appropriate due dates and scheduled dates for better timeline visibility
4. **Today Focus:** Use the "Today" button to quickly focus on current priorities
5. **Status Updates:** Update task status directly from the timeline for efficiency
## Keyboard Shortcuts
* **Ctrl/Cmd + Enter:** Submit quick capture input
* **Escape:** Clear quick capture input
* **Click:** Navigate to task location
* **Checkbox Click:** Toggle task completion status
## Integration
### File Types Supported
* **Markdown Files:** Full support with proper line navigation
* **Canvas Files:** Direct opening of canvas files
* **Mixed Content:** Handles both markdown and canvas task sources
### External Integrations
* **ICS Calendar:** Filters ICS badge events appropriately
* **Daily Notes:** Seamless integration with daily note workflows
* **Task Manager:** Real-time synchronization with the task management system
## Settings
You can read more about view settings on the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
### Specific Settings
* **Enable Timeline Sidebar:** Control whether the timeline sidebar feature is enabled
* **Auto Open on Startup:** Automatically open the timeline sidebar when the plugin starts
* **Show Completed Tasks:** Control visibility of completed tasks in the timeline
* **Focus Mode by Default:** Start the timeline in focus mode (showing only today's events)
* **Max Events to Show:** Limit the maximum number of events displayed in the timeline
file: ./content/docs/mcp-integration/clients/claude-code.mdx
meta: {
"title": "Claude Code Configuration",
"description": "Setup guide for Claude Code CLI with Task Genius MCP"
}
This guide shows you how to configure Claude Code to work with your Task Genius tasks directly from the command line.
## Prerequisites
* Claude Code installed ([installation guide](https://claude.ai/code))
* Task Genius MCP server enabled in Obsidian
* Your authentication credentials from Task Genius settings
## Quick Setup
Add Task Genius to Claude Code with one command:
```bash
claude mcp add --transport http obsidian-tasks http://127.0.0.1:7777/mcp \
--header "Authorization: Bearer YOUR_TOKEN+YOUR_APP_ID"
```
Get Your Credentials from Task Genius Settings
That's it! You can now manage your Obsidian tasks from Claude Code.
## Verify Your Setup
After adding Task Genius, test the connection:
```bash
claude mcp test obsidian-tasks
```
You should see:
```
✅ Connection successful
✅ Authentication valid
✅ 25+ tools available
```
## Basic Commands
```bash
# View your Task Genius configuration
claude mcp show obsidian-tasks
# Update credentials if needed
claude mcp update obsidian-tasks \
--header "Authorization: Bearer NEW_TOKEN+NEW_APP_ID"
# Remove and re-add if having issues
claude mcp remove obsidian-tasks
```
## Multiple Vaults
If you have multiple Obsidian vaults with Task Genius:
```bash
# Add personal vault
claude mcp add --transport http personal-vault \
http://127.0.0.1:7777/mcp \
--header "Authorization: Bearer TOKEN1+APPID1"
# Add work vault (different port)
claude mcp add --transport http work-vault \
http://127.0.0.1:7778/mcp \
--header "Authorization: Bearer TOKEN2+APPID2"
```
## Using Task Genius with Claude Code
### Interactive Session
Start Claude Code connected to your tasks:
```bash
claude --use obsidian-tasks
```
### Common Task Operations
```bash
# Today's tasks
claude --use obsidian-tasks "What tasks do I have today?"
# Create a new task
claude --use obsidian-tasks "Create task: Review quarterly report, priority 4, due tomorrow"
# Mark tasks complete
claude --use obsidian-tasks "Mark task 'Review quarterly report' as complete"
# Query by project
claude --use obsidian-tasks "Show all tasks for project ClientPresentation"
# Update priorities
claude --use obsidian-tasks "Set all overdue tasks to priority 5"
# Quick capture
claude --use obsidian-tasks "Add to inbox: Call John about proposal"
```
### Task Genius Specific Features
```bash
# Work with Task Genius projects
claude --use obsidian-tasks "List all my active projects with task counts"
# Use Task Genius contexts
claude --use obsidian-tasks "Show tasks in @office context"
# Batch operations
claude --use obsidian-tasks "Postpone all tasks tagged #waiting to next week"
# Daily note integration
claude --use obsidian-tasks "Add task to today's daily note: Team standup at 10am"
```
## Productivity Tips
### Shell Aliases
Add these to your `~/.bashrc` or `~/.zshrc` for quick access:
```bash
# Quick task operations
alias task="claude --use obsidian-tasks"
alias today="claude --use obsidian-tasks 'Show today\'s tasks'"
alias inbox="claude --use obsidian-tasks 'Show inbox tasks'"
# Task creation function
new_task() {
claude --use obsidian-tasks "Create task: $*"
}
# Daily review
alias review="claude --use obsidian-tasks 'Show overdue tasks and today\'s priorities'"
```
Usage:
```bash
task "What's due this week?"
new_task Call client about proposal
today
review
```
### Environment Variables
Store credentials securely:
```bash
# Add to ~/.bashrc or ~/.zshrc
export OBSIDIAN_TOKEN="your_token"
export OBSIDIAN_APP_ID="your_app_id"
# Use in configuration
claude mcp add --transport http obsidian-tasks \
http://127.0.0.1:7777/mcp \
--header "Authorization: Bearer ${OBSIDIAN_TOKEN}+${OBSIDIAN_APP_ID}"
```
## Troubleshooting
### Connection Failed
1. **Check Task Genius MCP is enabled:**
* Open Obsidian → Task Genius Settings → MCP Integration
* Ensure server is running (green status)
2. **Verify port availability:**
```bash
curl http://127.0.0.1:7777/health
```
3. **Test connection:**
```bash
claude mcp test obsidian-tasks --verbose
```
### Authentication Issues
1. **Get fresh credentials:**
Open MCP Settings
2. **Update configuration:**
```bash
claude mcp update obsidian-tasks \
--header "Authorization: Bearer NEW_TOKEN+NEW_APP_ID"
```
### Common Issues
* **"Connection refused"**: Task Genius MCP server not running
* **"401 Unauthorized"**: Invalid token or App ID
* **"No tools available"**: Server running but not properly configured
* **Timeout errors**: Large vault - increase timeout with `--timeout 60000`
## Quick Reference
### Essential Commands
```bash
# Setup
claude mcp add --transport http obsidian-tasks [URL] --header [AUTH]
# Management
claude mcp list # List all servers
claude mcp show obsidian-tasks # View configuration
claude mcp test obsidian-tasks # Test connection
claude mcp remove obsidian-tasks # Remove server
# Usage
claude --use obsidian-tasks # Interactive mode
claude --use obsidian-tasks "..." # Single command
```
### Task Genius MCP Tools
Available operations through Claude Code:
* Query tasks (by date, project, context, priority)
* Create tasks (with due dates, priorities, tags)
* Update task status (complete, postpone, delete)
* Batch operations (update multiple tasks)
* Daily note integration
* Project and context management
## Best Practices
1. **Use aliases** for frequent operations (see Productivity Tips)
2. **Store credentials** in environment variables, not in commands
3. **Be specific** in queries to get better results
4. **Use projects and contexts** to organize tasks effectively
5. **Batch similar operations** for better performance
## Next Steps
* Explore [Task Genius use cases](/docs/mcp-integration/use-cases) for workflow ideas
* Check the [API reference](/docs/mcp-integration/api-reference) for all available operations
* See [troubleshooting guide](/docs/mcp-integration/troubleshooting) if you encounter issues
**Pro Tip**: Start with simple queries like "Show today's tasks" to get familiar with Task Genius through Claude Code.
file: ./content/docs/mcp-integration/clients/claude-desktop.mdx
meta: {
"title": "Claude Desktop Configuration",
"description": "Setup guide for Claude Desktop with Task Genius MCP"
}
This guide shows you how to configure Claude Desktop to work with your Task Genius tasks.
## Prerequisites
* Claude Desktop installed
* Task Genius MCP server enabled in Obsidian
* Your authentication credentials from Task Genius settings
## Configuration Steps
### Step 1: Locate Configuration File
Find your Claude Desktop configuration file:
**macOS:**
```bash
~/Library/Application Support/Claude/claude_desktop_config.json
```
**Windows:**
```bash
%APPDATA%\Claude\claude_desktop_config.json
```
**Linux:**
```bash
~/.config/Claude/claude_desktop_config.json
```
### Step 2: Create or Edit Configuration
If the file doesn't exist, create it with this structure:
```json
{
"mcpServers": {
"obsidian-tasks": {
"command": "curl",
"args": [
"-X", "POST",
"-H", "Authorization: Bearer YOUR_TOKEN+YOUR_APP_ID",
"-H", "Content-Type: application/json",
"--data-raw", "@-",
"http://127.0.0.1:7777/mcp"
]
}
}
}
```
### Step 3: Get Your Credentials
Open MCP Settings
Copy:
1. Authentication Token
2. App ID
3. Server URL (if using custom port)
### Step 4: Update Configuration
Replace placeholders with your actual values:
* `YOUR_TOKEN` → Your authentication token
* `YOUR_APP_ID` → Your vault's App ID
### Step 5: Restart Claude Desktop
1. Completely quit Claude Desktop (not just close window)
2. Restart the application
3. The MCP server should connect automatically
## Advanced Configuration
### Multiple Vaults
Connect to multiple Obsidian vaults:
```json
{
"mcpServers": {
"personal-tasks": {
"command": "curl",
"args": [
"-X", "POST",
"-H", "Authorization: Bearer TOKEN1+APPID1",
"-H", "Content-Type: application/json",
"--data-raw", "@-",
"http://127.0.0.1:7777/mcp"
]
},
"work-tasks": {
"command": "curl",
"args": [
"-X", "POST",
"-H", "Authorization: Bearer TOKEN2+APPID2",
"-H", "Content-Type: application/json",
"--data-raw", "@-",
"http://127.0.0.1:7778/mcp"
]
}
}
}
```
### Remote Vault Access
For accessing a vault on another machine:
```json
{
"mcpServers": {
"remote-vault": {
"command": "curl",
"args": [
"-X", "POST",
"-H", "Authorization: Bearer YOUR_TOKEN+YOUR_APP_ID",
"-H", "Content-Type: application/json",
"--data-raw", "@-",
"http://192.168.1.100:7777/mcp"
]
}
}
}
```
## Using Task Genius in Claude Desktop
Once configured, interact naturally with your tasks:
### Common Operations
```text
"Show today's high-priority tasks"
"Create task: Review quarterly report, priority 4, due tomorrow"
"Mark 'Review quarterly report' as complete"
"What tasks are overdue?"
"Show all tasks for project ClientPresentation"
"List tasks in @office context"
"Add task to today's daily note"
```
### Daily Workflows
```text
"Help me plan my day based on my tasks"
"What should I focus on this morning?"
"Show me overdue tasks that need attention"
"What did I complete yesterday?"
"Create a summary of this week's progress"
```
## Key Features
* **Context Awareness**: Claude remembers what you're discussing
* **Batch Operations**: Update multiple tasks at once
* **Smart Suggestions**: Get recommendations based on your task patterns
* **Natural Language**: No need to learn specific commands
## Troubleshooting
### Connection Issues
1. **Verify Task Genius MCP is running:**
* Open Obsidian → Task Genius Settings → MCP Integration
* Check server status is green
2. **Test connection:**
```bash
curl -X POST http://127.0.0.1:7777/health
```
3. **Check configuration file:**
* Ensure JSON syntax is valid
* Verify token format: `Bearer YOUR_TOKEN+YOUR_APP_ID`
* No extra spaces or quotes
### Authentication Errors
* **"Unauthorized"**: Invalid token or App ID
* **"Connection refused"**: MCP server not running
* **Solution**: Get fresh credentials from MCP Settings
### Windows-Specific
If curl isn't found, use full path:
```json
{
"command": "C:\\Windows\\System32\\curl.exe"
}
```
## Best Practices
1. **Security**: Never share or commit your configuration file
2. **Naming**: Use descriptive names like `personal-tasks` or `work-projects`
3. **Conversations**: Start new chats for different task contexts
4. **Performance**: Be specific in queries for faster responses
## Next Steps
* Explore [Task Genius use cases](/docs/mcp-integration/use-cases) for workflow ideas
* Configure [other clients](/docs/mcp-integration/clients) like Claude Code or Cursor
* Check the [API reference](/docs/mcp-integration/api-reference) for all available operations
* See [troubleshooting guide](/docs/mcp-integration/troubleshooting) if you encounter issues
**Quick Tip**: Start with simple requests like "show today's tasks" to get familiar with Task Genius in Claude Desktop.
file: ./content/docs/mcp-integration/clients/cursor.mdx
meta: {
"title": "Cursor Configuration",
"description": "Setup guide for Cursor with Task Genius MCP"
}
This guide shows you how to configure Cursor to work with your Task Genius tasks.
## Prerequisites
* Cursor installed
* Task Genius MCP server enabled in Obsidian
* Your authentication credentials from Task Genius settings
## One-Click Installation (Recommended)
The easiest way to configure Cursor is using the automatic deeplink installation:
### Step 1: Open MCP Settings
Open MCP Settings in Obsidian
### Step 2: Find Cursor Section
Navigate to the "Client Configuration" section and locate Cursor.
### Step 3: Click Install
Click the "Add to Cursor" button. This will:
1. Open Cursor automatically
2. Add the Task Genius MCP server
3. Configure authentication
4. Verify the connection
## Manual Configuration
Cursor supports multiple configuration methods for MCP servers.
### Method 1: Using mcp.json (Recommended)
#### Project-specific Configuration
Create `.cursor/mcp.json` in your project root:
```json
{
"mcpServers": {
"task-genius": {
"transport": "http",
"url": "http://127.0.0.1:7777/mcp",
"headers": {
"Authorization": "Bearer YOUR_TOKEN+YOUR_APP_ID"
}
}
}
}
```
#### Global Configuration
For system-wide access, create `~/.cursor/mcp.json`:
```json
{
"mcpServers": {
"obsidian-tasks": {
"transport": "http",
"url": "http://127.0.0.1:7777/mcp",
"headers": {
"Authorization": "Bearer YOUR_TOKEN+YOUR_APP_ID"
}
}
}
}
```
### Method 2: Environment Variables
Store credentials securely using environment variables:
```json
{
"mcpServers": {
"task-genius": {
"transport": "http",
"url": "http://127.0.0.1:7777/mcp",
"env": {
"TASK_GENIUS_TOKEN": "YOUR_TOKEN",
"TASK_GENIUS_APP_ID": "YOUR_APP_ID"
},
"headers": {
"Authorization": "Bearer ${TASK_GENIUS_TOKEN}+${TASK_GENIUS_APP_ID}"
}
}
}
}
```
### Step 2: Get Your Credentials
Get Credentials from Task Genius
Copy:
* Authentication Token
* App ID
### Step 3: Apply Configuration
1. Replace `YOUR_TOKEN` and `YOUR_APP_ID` with actual values
2. Save the mcp.json file
3. Restart Cursor or reload the window
## Transport Methods
Task Genius MCP server uses HTTP transport, which Cursor fully supports:
* **HTTP**: Best for Task Genius integration
* **SSE**: Alternative for real-time updates (if configured)
* **stdio**: Not applicable for Task Genius
### Extension API (Advanced)
For programmatic registration, Cursor provides an extension API:
```javascript
// Register Task Genius MCP server programmatically
vscode.cursor.mcp.registerServer('task-genius', {
transport: 'http',
url: 'http://127.0.0.1:7777/mcp',
headers: {
'Authorization': 'Bearer YOUR_TOKEN+YOUR_APP_ID'
}
});
```
This is useful for:
* Enterprise deployments
* Automated setup workflows
* Dynamic configuration
## Advanced Configuration
### Multiple Vaults
Configure multiple Obsidian vaults with different ports:
```json
{
"mcpServers": {
"personal-tasks": {
"transport": "http",
"url": "http://127.0.0.1:7777/mcp",
"headers": {
"Authorization": "Bearer TOKEN1+APPID1"
}
},
"work-tasks": {
"transport": "http",
"url": "http://127.0.0.1:7778/mcp",
"headers": {
"Authorization": "Bearer TOKEN2+APPID2"
}
}
}
}
```
### Remote Access
For accessing Task Genius from another machine:
```json
{
"mcpServers": {
"remote-vault": {
"transport": "http",
"url": "http://192.168.1.100:7777/mcp",
"headers": {
"Authorization": "Bearer YOUR_TOKEN+YOUR_APP_ID"
}
}
}
}
```
## Using Task Genius in Cursor
### Composer Agent Integration
The Composer Agent automatically uses Task Genius tools when relevant. Simply describe what you need:
```
"Show today's high-priority tasks"
"Create task: Review quarterly report, priority 4, due tomorrow"
"Mark 'Review quarterly report' as complete"
"What tasks are overdue?"
"Show all tasks for project ClientPresentation"
```
### Tool Management
#### Toggling Tools
Enable or disable Task Genius tools directly in chat:
* Click tool names in the Available Tools list
* Disabled tools won't be loaded into context
#### Tool Approval
By default, Cursor asks for approval before using MCP tools:
* Click the arrow next to tool name to see arguments
* Approve individual operations
* Enable auto-run for trusted operations
#### Auto-run Mode
For faster workflow, enable auto-run:
* Tools execute without asking for permission
* Similar to terminal command auto-execution
* Configure in Cursor settings
## Troubleshooting
### Connection Failed
If Cursor can't connect to Task Genius:
1. **Verify server is running**:
```bash
curl http://127.0.0.1:7777/health
```
2. **Check authentication**:
* Ensure token is correct
* Verify App ID is included
* Try regenerating token
3. **Test with curl**:
```bash
curl -X POST http://127.0.0.1:7777/mcp \
-H "Authorization: Bearer YOUR_TOKEN+YOUR_APP_ID" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize"}'
```
### Tools Not Available
If MCP tools don't appear in Cursor:
1. **Restart Cursor** after configuration changes
2. **Check logs** in Cursor's developer console
3. **Verify configuration** syntax is correct
4. **Ensure MCP server** is enabled in Obsidian
### Authentication Errors
Common authentication issues:
| Error | Solution |
| ---------------- | ------------------------------------- |
| "Invalid token" | Regenerate token in Obsidian settings |
| "Missing app ID" | Ensure format is `Bearer TOKEN+APPID` |
| "Unauthorized" | Check token hasn't expired or changed |
### Performance Issues
For better performance:
1. **Use specific queries** instead of broad requests
2. **Limit results** for large vaults
3. **Enable caching** if available in your Cursor version
## Security Considerations
When using Task Genius with Cursor:
1. **Verify the source**: Task Genius is an official Obsidian plugin
2. **Review permissions**: MCP only accesses your task data
3. **Limit API access**: Use local-only mode when possible
4. **Secure credentials**: Never share or commit tokens
## Best Practices
1. **Configuration Location**:
* Use project-specific `.cursor/mcp.json` for vault-specific tasks
* Use global `~/.cursor/mcp.json` for personal task management
2. **Authentication**:
* Store tokens in environment variables when possible
* Regenerate tokens periodically
* Use separate tokens for different vaults
3. **Usage**:
* Be specific in queries for better results
* Use tool toggling to control which operations are available
* Enable auto-run only for trusted operations
## Example Workflows
### Daily Review
```
"Show today's tasks by priority"
"What tasks did I complete yesterday?"
"List overdue high-priority tasks"
```
### Project Management
```
"Show all tasks for project Q1Planning"
"Find incomplete tasks tagged #milestone"
"Create task in project: Design review meeting"
```
### Quick Capture
```
"Add to inbox: Call client about proposal"
"Create task in daily note: Team standup at 10am"
"Quick task: Review pull request #123"
```
## Next Steps
* Explore [Task Genius use cases](/docs/mcp-integration/use-cases) for workflow ideas
* Check the [API reference](/docs/mcp-integration/api-reference) for all available operations
* Configure [other clients](/docs/mcp-integration/clients) like Claude Code
* See [troubleshooting guide](/docs/mcp-integration/troubleshooting) if you encounter issues
**Quick Tip**: Start with simple queries like "show today's tasks" to get familiar with Task Genius in Cursor.
file: ./content/docs/mcp-integration/clients/vscode.mdx
meta: {
"title": "VS Code Configuration",
"description": "Setup guide for VS Code with Task Genius MCP"
}
This guide shows you how to configure VS Code to work with your Task Genius tasks using Model Context Protocol (MCP).
## Prerequisites
* VS Code 1.102 or later
* GitHub Copilot access
* Task Genius MCP server enabled in Obsidian
* Your authentication credentials from Task Genius settings
## Quick Setup
The fastest way to add Task Genius to VS Code:
### Step 1: Enable MCP Support
MCP support is enabled by default in VS Code. Verify with:
* Open Settings (`Cmd/Ctrl + ,`)
* Search for `chat.mcp.enabled`
* Ensure it's checked
### Step 2: Add Task Genius Server
Run the command from Command Palette (`Cmd/Ctrl + Shift + P`):
```
MCP: Add Server
```
Choose:
1. **Server Type**: HTTP
2. **Name**: `task-genius`
3. **URL**: `http://127.0.0.1:7777/mcp`
4. **Scope**: Workspace or Global
### Step 3: Configure Authentication
Get Credentials from Task Genius
Add authentication header in the configuration dialog:
* **Header Name**: `Authorization`
* **Header Value**: `Bearer YOUR_TOKEN+YOUR_APP_ID`
## Manual Configuration
### Workspace Configuration
Create `.vscode/mcp.json` in your project:
```json
{
"servers": {
"task-genius": {
"type": "http",
"url": "http://127.0.0.1:7777/mcp",
"headers": {
"Authorization": "Bearer YOUR_TOKEN+YOUR_APP_ID"
}
}
}
}
```
### Global Configuration
For all workspaces, run:
```
MCP: Open User Configuration
```
Or create/edit `~/mcp.json`:
```json
{
"servers": {
"task-genius": {
"type": "http",
"url": "http://127.0.0.1:7777/mcp",
"headers": {
"Authorization": "Bearer YOUR_TOKEN+YOUR_APP_ID"
}
}
}
}
```
## Using Task Genius in VS Code
### Agent Mode
1. Open Chat view (`Ctrl/Cmd + Shift + I`)
2. Select **Agent** mode from dropdown
3. Click **Tools** to see Task Genius tools
4. Start chatting about your tasks
### Common Operations
```text
"Show today's high-priority tasks"
"Create task: Review code changes, priority 4"
"Mark 'Review code changes' as complete"
"List overdue tasks"
"Show tasks for project ClientAPI"
```
### Direct Tool Reference
Type `#` in chat to directly reference tools:
```text
#task-genius.create_task Create a new feature task
#task-genius.query_tasks Show all incomplete tasks
```
### Tool Sets
Group frequently used tools:
1. Create a tool set in settings
2. Name it (e.g., "daily-review")
3. Add Task Genius tools
4. Reference with `#daily-review` in chat
## Advanced Configuration
### Multiple Vaults
```json
{
"servers": {
"personal-tasks": {
"type": "http",
"url": "http://127.0.0.1:7777/mcp",
"headers": {
"Authorization": "Bearer TOKEN1+APPID1"
}
},
"work-tasks": {
"type": "http",
"url": "http://127.0.0.1:7778/mcp",
"headers": {
"Authorization": "Bearer TOKEN2+APPID2"
}
}
}
}
```
### Secure Credentials
Use input variables to avoid hardcoding tokens:
```json
{
"inputs": [
{
"type": "promptString",
"id": "task-genius-auth",
"description": "Task Genius Authentication (TOKEN+APPID)",
"password": true
}
],
"servers": {
"task-genius": {
"type": "http",
"url": "http://127.0.0.1:7777/mcp",
"headers": {
"Authorization": "Bearer ${input:task-genius-auth}"
}
}
}
}
```
### Dev Container Support
Add to `.devcontainer/devcontainer.json`:
```json
{
"customizations": {
"vscode": {
"mcp": {
"servers": {
"task-genius": {
"type": "http",
"url": "http://host.docker.internal:7777/mcp",
"headers": {
"Authorization": "Bearer ${localEnv:TASK_GENIUS_AUTH}"
}
}
}
}
}
}
}
```
## Settings & Features
### Auto-start Servers
Enable automatic server start:
```json
{
"chat.mcp.autostart": true
}
```
### Tool Confirmation
Control tool execution approval:
* **Always ask**: Default, confirms each tool use
* **Auto-confirm specific tools**: Use dropdown in confirmation dialog
* **Trust all**: Enable in settings (use with caution)
### Manage Servers
Access server management:
1. **Extensions View**: `MCP SERVERS - INSTALLED` section
2. **Command Palette**: `MCP: List Servers`
3. **Configuration File**: Click inline actions in `mcp.json`
Available actions:
* Start/Stop server
* View logs
* Reset cached tools
* Test connection
* Uninstall
## Troubleshooting
### Connection Issues
1. **Verify Task Genius MCP is running:**
```bash
curl http://127.0.0.1:7777/health
```
2. **Check VS Code MCP status:**
```
MCP: Show Installed Servers
```
3. **View server logs:**
```
MCP: List Servers > task-genius > Show Output
```
### Authentication Errors
| Error | Solution |
| ----------------------- | ------------------------------------------- |
| "401 Unauthorized" | Regenerate token in Obsidian settings |
| "Invalid header format" | Use format: `Bearer TOKEN+APPID` |
| "Connection refused" | Ensure MCP server is enabled in Task Genius |
### Tools Not Available
1. **Refresh tools cache:**
```
MCP: Reset Cached Tools
```
2. **Restart server:**
```
MCP: List Servers > task-genius > Restart
```
3. **Check tool limit:**
* Maximum 128 tools per request
* Deselect unused tools in Tools picker
## Best Practices
### Performance
* Be specific in queries for faster responses
* Use tool sets for common operations
* Enable virtual tools for large tool collections:
```json
{
"github.copilot.chat.virtualTools.threshold": 50
}
```
### Security
* Store credentials using input variables
* Use workspace settings for project-specific tasks
* Never commit `mcp.json` with credentials
* Regularly regenerate authentication tokens
### Workflow Tips
1. **Daily Review:**
* Create "daily-review" tool set
* Include query\_tasks, update\_task\_status tools
* Quick access with `#daily-review`
2. **Project Management:**
* Workspace-specific configuration per project
* Use project tags in Task Genius
* Filter by project in queries
3. **Quick Capture:**
* Set up keyboard shortcut for Chat view
* Use `#task-genius.create_task` for quick entry
* Enable auto-start for instant access
## Integration Examples
### With Git Workflows
```text
"Create task for PR #123 review"
"List tasks tagged with current-sprint"
"Mark deployment tasks as complete"
```
### With Development Tasks
```text
"Add task: Fix TypeScript errors in components folder"
"Show all tasks related to API refactoring"
"Create subtasks for implementing user authentication"
```
### With Team Collaboration
```text
"List tasks assigned to team-frontend project"
"Show high-priority bugs for this week"
"Create task in daily note: Discuss architecture changes"
```
## Next Steps
* Explore [Task Genius use cases](/docs/mcp-integration/use-cases) for workflow ideas
* Check the [API reference](/docs/mcp-integration/api-reference) for all available operations
* Learn about [MCP prompts and resources](/docs/mcp-integration/advanced-features)
* See [troubleshooting guide](/docs/mcp-integration/troubleshooting) for detailed solutions
**Pro Tip**: Start with Agent mode and the Tools picker to explore Task Genius capabilities before creating custom tool sets.
file: ./content/docs/task-view/custom-view/index.mdx
meta: {
"title": "Custom View"
}
import { VersionCallout } from "@/components/VersionCallout";
import { Edit3Icon, TrashIcon, CopyIcon } from "lucide-react";
In Task Genius, you can create custom views to display tasks in a specific way.
## Create a custom view
1. Open the settings page of [Task Genius View](/docs/task-view/basic-view-settings#basic-settings).
2. Click on the button `Add Custom View`.
3. Input the view name, and then select a icon for the view.
4. Select the `View Type` you want to create. (You can select [Standard View](/docs/task-view/custom-view/standard-view) or [Two Column View](/docs/task-view/custom-view/two-column-view))
5. Configure the view settings.
6. Click on the button `Save`.
## Duplicate a custom view
You can duplicate a custom view by clicking the button.
## Edit a custom view
After creating a custom view, you can press the button to edit the view.
Or you can right-click the view in the sidebar and select `Edit View` to edit the view.
## Delete a custom view
After creating a custom view, you can press the button to delete the view.
## Use a custom view
After creating a custom view, you can use it by clicking the view in the sidebar.
## Settings
You can read more about the settings in the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
file: ./content/docs/task-view/custom-view/standard-view.mdx
meta: {
"title": "Standard View"
}
import { VersionCallout } from "@/components/VersionCallout";
All standard view are inherit from the [Inbox View](/docs/task-view/inbox-view).
## Usage
You can read more about the usage in the [Inbox View](/docs/task-view/inbox-view) page.
## Settings
1. Open the settings page of [Task Genius View](/docs/task-view/basic-view-settings#basic-settings).
2. Click on the button `Add Custom View`.
3. Input the view name, and then select a icon for the view.
4. Select the `View Type` as `Standard View`.
5. Configure the view settings.
6. Click on the button `Save`.
7. All done.
You can read more about the settings in the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
After reload Obsidian, you will see the new view in the sidebar.
file: ./content/docs/task-view/custom-view/two-column-view.mdx
meta: {
"title": "Two Column View"
}
import { VersionCallout } from "@/components/VersionCallout";
import { ListPlusIcon } from "lucide-react";
Two column view is a view that displays tasks in two columns.
## Usage
When creating or editing a custom view, if you select "Two Column View" as the `View Type`, the following settings become available:
* **Group by Task Property**: Select which task property (e.g., Tags, Project, Priority, Status, Due Date, File Path) to use for grouping items in the left column. The title of the left column will often default based on this selection (e.g., selecting "Tags" might default the left column title to "Tags").
* *Default*: `Tags`
* **Left Column Title**: The title displayed at the top of the left column, which lists the groups (based on the selected property).
* *Default*: `Items` (or based on the "Group by Task Property" selection)
* **Right Column Title**: The default title displayed at the top of the right column when a single group is selected from the left column.
* *Default*: `Tasks`
* **Multi-select Text**: The text displayed in the right column's title bar when multiple groups are selected in the left column.
* *Default*: `selected items`
* **Empty State Text**: The text displayed in the right column when no group is selected in the left column.
* *Default*: `No items selected`
## Task List
The task list is the list of tasks that will be displayed in the right column. The task list is influenced by the basic filter settings.
## Group List
The group list is the list of groups that will be displayed in the left column. The group list is influenced by the "Group by Task Property" setting.
### Multi-select
In the top-right corner of the group list, you can see a multi-select button . You can use it to select multiple groups.
After you press the multi-select button, you can use the left mouse button to select a group and then press the `Ctrl/Cmd` key to select another group.
## Settings
1. Open the settings page of [Task Genius View](/docs/task-view/basic-view-settings#basic-settings).
2. Click on the button `Add Custom View`.
3. Input the view name, and then select a icon for the view.
4. Select the `View Type` as `Two Column View`.
5. Configure the view settings especially the `Group by Task Property` setting.
6. Click on the button `Save`.
7. All done.
You can read more about the settings in the [Basic view settings](/docs/task-view/basic-view-settings#basic-settings) page.
After reload Obsidian, you will see the new view in the sidebar.
file: ./content/docs/task-view/filter/advanced-filter.mdx
meta: {
"title": "Advanced Filter"
}
import { VersionCallout } from "@/components/VersionCallout";
import { PlusIcon, XIcon } from "lucide-react";
The Advanced Filter is a powerful tool that allows you to filter tasks based on complex criteria.
## Scope
Currently, the advanced filter is only available in the [Plan(Gantt) view](/docs/task-view/plan-view) and also the [Status(Kanban) view](/docs/task-view/status-view).
## Usage
1. Click the **Add filter** button to open a dropdown.
2. Select a **category** to filter by (e.g., `Tag`, `Priority`, `Project`).
3. Select the specific **value** within that category (e.g., `#urgent`, `🔺 Highest`, `MyProject`).
4. Available filter categories and options are dynamically generated based on the tasks currently loaded.
5. Active filters are displayed as removable "pills" above the board (via ).
6. You can add multiple filters. Tasks must match **all** active filters to be displayed.
7. Click the **Clear all** button to remove all active filters at once.
8. The filterable criteria include:
* Status
* Tag
* Project
* Context
* Priority (often represented by icons like 🔺, ⏫, 🔼)
* Completed (Yes/No)
* File Path
9. Applying, adding, or removing filters dynamically updates the tasks in the view.
file: ./content/docs/task-view/filter/basic-filter.mdx
meta: {
"title": "Basic Filter"
}
import { VersionCallout } from "@/components/VersionCallout";
The basic filter is a simple filter that allows you to filter tasks by content.
## Scope
Currently, the basic filter is available in all views(except the [Plan(Gantt) view](/docs/task-view/plan-view) or [Status(Kanban) view](/docs/task-view/status-view)).
## Usage
You can find the basic filter in the top right corner of the view. When you input a keyword, the tasks that contain the keyword will be filtered.
file: ./content/docs/task-view/filter/index.mdx
meta: {
"title": "Filter"
}
Task Genius views provide a variety of filters to help you find the tasks you need.
file: ./content/docs/task-view/filter/popover-filter.mdx
meta: {
"title": "Popover Filter"
}
import { VersionCallout } from "@/components/VersionCallout";
import {
Edit3Icon,
PlusIcon,
CopyIcon,
Trash2Icon,
GripVerticalIcon,
SaveIcon,
FolderOpenIcon,
} from "lucide-react";
The Popover Filter is an advanced filtering system that provides a comprehensive interface for creating complex filter conditions with multiple groups and logical operators.
## Overview
The Popover Filter allows you to create sophisticated filter configurations using:
* Multiple filter groups with different logical operators (AND, OR, NOT)
* Individual filters within each group with various conditions
* Drag-and-drop reordering of filter groups
* Real-time filter application with debounced updates
## Features
### Filter Groups
* **Root Condition**: Choose how filter groups are combined (Any, All, None)
* **Group Condition**: Set how filters within each group are combined (All, Any, None)
* **Drag & Drop**: Reorder filter groups using the handle
* **Duplicate Groups**: Copy entire filter groups with the button
* **Remove Groups**: Delete filter groups with the button
### Filter Properties
The system supports filtering by various task properties:
* **Content**: Filter by task text content
* **Status**: Filter by task status
* **Priority**: Filter by task priority level
* **Due Date**: Filter by task due dates
* **Start Date**: Filter by task start dates
* **Scheduled Date**: Filter by scheduled dates
* **Tags**: Filter by task tags
* **File Path**: Filter by the file containing the task
* **Completed**: Filter by completion status
### Filter Conditions
Different properties support different condition types:
#### Text Properties (Content, File Path, Status)
* Contains / Does not contain
* Is / Is not
* Starts with / Ends with
* Is empty / Is not empty
#### Date Properties (Due Date, Start Date, Scheduled Date)
* Is / Is not
* Greater than (>) / Less than (\<)
* Greater than or equal (>=) / Less than or equal (\<=)
* Is empty / Is not empty
#### Priority Property
* Is / Is not
* Is empty / Is not empty
#### Tags Property
* Contains / Does not contain
* Is empty / Is not empty
#### Completed Property
* Is true / Is false
## Usage
### Creating Filter Groups
1. Click the **Add filter group** button to create a new filter group
2. Choose the group condition (All, Any, None) to determine how filters within the group are combined
3. Add individual filters to the group using the **Add filter** button
### Configuring Individual Filters
1. **Select Property**: Choose what aspect of the task to filter by
2. **Select Condition**: Choose the comparison operator
3. **Enter Value**: Provide the value to compare against (if required)
4. **Remove Filter**: Use the button to delete unwanted filters
### Managing Filter Groups
* **Reorder**: Drag filter groups using the handle
* **Duplicate**: Click the button to copy a filter group
* **Remove**: Click the button to delete a filter group
### Root Condition Settings
At the top level, choose how multiple filter groups are combined:
* **Any**: Tasks matching any filter group will be shown
* **All**: Tasks must match all filter groups to be shown
* **None**: Tasks matching any filter group will be hidden
### Save or load filter
* **Save Filter**: Click the button to save the current filter configuration
* **Load Filter**: Click the button to load a previously saved filter configuration
## Real-time Updates
The Popover Filter system provides real-time filtering with:
* **Automatic Saving**: Filter configurations are automatically saved to local storage
* **Debounced Updates**: Filter changes are applied with a slight delay to prevent excessive updates
* **Event Broadcasting**: Filter changes trigger events that other components can listen to
## Data Persistence
Filter configurations are automatically saved and restored:
* Settings persist across application sessions
* Invalid configurations are automatically reset to defaults
* Filter state can be programmatically loaded and retrieved
file: ./content/docs/task-view/filter/view-filter.mdx
meta: {
"title": "View Filter Settings"
}
import { VersionCallout } from "@/components/VersionCallout";
import { Edit3Icon } from "lucide-react";
A view filter setting is a predefined filter that is based on the view you are currently in.
## Usage
1. Open the settings of Task Genius.
2. Go to the `View` tab.
3. Select the view you want to filter.
4. Click the button.
5. Set the filter you want to use.
You can read more about the filter settings in the [Basic view settings](/docs/task-view/basic-view-settings) page.