Orchestre v5 Resource Reference

Overview

Orchestre v5 provides contextual resources through the MCP (Model Context Protocol) resource system. Resources are read-only data sources that prompts can access to provide better context and more accurate implementations.

Resource URI Scheme

All Orchestre resources follow the URI pattern:

orchestre://[namespace]/[type]/[identifier]

Available Resource Namespaces

Memory Resources (orchestre://memory/)

Provides access to the distributed memory system.

URI Pattern	Description	Content Type
orchestre://memory/project	Main project memory (CLAUDE.md)	Markdown
orchestre://memory/features/*	Feature-specific documentation	Markdown
orchestre://memory/architecture	Architecture decisions and patterns	Markdown
orchestre://memory/sessions/*	Development session logs	Markdown
orchestre://memory/patterns/*	Discovered code patterns	Markdown
orchestre://memory/reviews/*	Code review results	Markdown
orchestre://memory/knowledge/*	Knowledge base entries	Markdown

Example Usage:

orchestre://memory/features/authentication.md
orchestre://memory/sessions/2024-01-15-auth-impl.md
orchestre://memory/patterns/repository-pattern.md

Pattern Resources (orchestre://patterns/)

Provides access to best practices and implementation patterns.

URI Pattern	Description	Content Type
orchestre://patterns/architecture	Architectural patterns	JSON/Markdown
orchestre://patterns/implementation	Code implementation patterns	JSON/Markdown
orchestre://patterns/saas	SaaS-specific patterns	JSON/Markdown
orchestre://patterns/security	Security best practices	JSON/Markdown
orchestre://patterns/enterprise	Enterprise feature patterns	JSON/Markdown
orchestre://patterns/multi-tenancy	Multi-tenancy patterns	JSON/Markdown
orchestre://patterns/discovered	Project-specific discovered patterns	JSON/Markdown

Example Content Structure:

{
  "pattern": "Repository Pattern",
  "category": "architecture",
  "description": "Abstracts data access logic",
  "implementation": {
    "typescript": "class UserRepository { ... }",
    "examples": ["src/repositories/user.ts"]
  },
  "when_to_use": ["Complex queries", "Multiple data sources"],
  "trade_offs": {
    "pros": ["Testability", "Flexibility"],
    "cons": ["Additional abstraction layer"]
  }
}

Template Resources (orchestre://templates/)

Provides template-specific resources and configurations.

URI Pattern	Description	Content Type
orchestre://templates/saas-mvp	SaaS MVP templates	JSON
orchestre://templates/saas-components	Reusable SaaS components	JSON
orchestre://templates/documentation	Documentation templates	Markdown
orchestre://templates/[name]/config	Template configuration	JSON
orchestre://templates/[name]/patterns	Template-specific patterns	JSON

Template Configuration Example:

{
  "template": "makerkit-nextjs",
  "features": {
    "authentication": {
      "provider": "supabase",
      "methods": ["email", "oauth"]
    },
    "payments": {
      "provider": "stripe",
      "features": ["subscriptions", "one-time"]
    }
  },
  "structure": {
    "type": "monorepo",
    "packages": ["web", "mobile", "shared"]
  }
}

Context Resources (orchestre://context/)

Provides current working context.

URI Pattern	Description	Content Type
orchestre://context/recent	Recent development context	JSON
orchestre://context/current	Current working context	JSON
orchestre://context/environment	Environment information	JSON

Context Structure Example:

{
  "recent_files": [
    "src/features/auth/login.tsx",
    "src/features/auth/hooks.ts"
  ],
  "recent_patterns": ["React hooks", "Form validation"],
  "current_task": "Implementing OAuth login",
  "session_start": "2024-01-15T10:00:00Z",
  "completed_tasks": 3
}

Project Resources (orchestre://project/)

Provides project-specific information.

URI Pattern	Description	Content Type
orchestre://project/config	Project configuration	JSON
orchestre://project/structure	Project structure analysis	JSON
orchestre://project/dependencies	Dependency information	JSON
orchestre://project/techstack	Technology stack details	JSON

Resource Access by Prompts

Different prompts automatically include relevant resources:

orchestre-orchestrate

• orchestre://memory/project
• orchestre://patterns/architecture

orchestre-execute-task

• orchestre://memory/project
• orchestre://context/recent
• orchestre://patterns/implementation

orchestre-compose-saas-mvp

• orchestre://patterns/saas
• orchestre://templates/saas-mvp

orchestre-generate-implementation-tutorial

• orchestre://patterns/saas
• orchestre://memory/project
• orchestre://templates/saas-components

orchestre-security-audit

• orchestre://patterns/security
• orchestre://memory/project

orchestre-add-enterprise-feature

• orchestre://patterns/enterprise
• orchestre://memory/features

orchestre-migrate-to-teams

• orchestre://patterns/multi-tenancy
• orchestre://memory/architecture

orchestre-document-feature

• orchestre://memory/features
• orchestre://templates/documentation

orchestre-discover-context

• orchestre://memory/project
• orchestre://patterns/discovered

Resource Content Examples

Memory Resource Example

# Feature: Authentication System

## Overview
Multi-provider authentication system supporting email/password and OAuth.

## Implementation Details
- **Provider**: Supabase Auth
- **OAuth Providers**: Google, GitHub, Microsoft
- **Session Management**: JWT with refresh tokens
- **MFA**: TOTP-based two-factor authentication

## Architecture
### Components
- `AuthProvider`: React context for auth state
- `useAuth`: Hook for accessing auth functions
- `AuthGuard`: Component for protecting routes

### Security Measures
- Rate limiting on login attempts
- Secure session storage
- CSRF protection
- Account lockout after failed attempts

Pattern Resource Example

{
  "pattern": "Multi-tenant Data Isolation",
  "type": "architectural",
  "description": "Ensures data isolation between tenants in a shared database",
  "strategies": [
    {
      "name": "Row-Level Security",
      "implementation": "Add tenant_id to all tables and filter queries",
      "pros": ["Simple", "Cost-effective"],
      "cons": ["Requires discipline", "Performance considerations"],
      "example": "WHERE tenant_id = current_tenant_id()"
    },
    {
      "name": "Schema Separation",
      "implementation": "Separate schema per tenant",
      "pros": ["Strong isolation", "Easy backup/restore"],
      "cons": ["Complex migrations", "Resource overhead"]
    }
  ],
  "best_practices": [
    "Always include tenant_id in queries",
    "Use database-level RLS policies",
    "Audit data access regularly",
    "Test isolation thoroughly"
  ]
}

Template Resource Example

{
  "component": "SubscriptionManager",
  "category": "payments",
  "description": "Manages subscription lifecycle with Stripe",
  "dependencies": ["stripe", "@stripe/stripe-js"],
  "files": [
    {
      "path": "components/SubscriptionManager.tsx",
      "type": "component"
    },
    {
      "path": "lib/stripe-client.ts",
      "type": "utility"
    },
    {
      "path": "api/webhooks/stripe.ts",
      "type": "api"
    }
  ],
  "configuration": {
    "environment_variables": [
      "STRIPE_PUBLIC_KEY",
      "STRIPE_SECRET_KEY",
      "STRIPE_WEBHOOK_SECRET"
    ]
  }
}

Creating Custom Resources

While Orchestre provides standard resources, you can extend the system:

1. Custom Memory Resources

Place markdown files in .orchestre/memory/custom/:

.orchestre/memory/custom/deployment-guide.md
.orchestre/memory/custom/api-conventions.md

2. Project-Specific Patterns

Document patterns in .orchestre/patterns/:

.orchestre/patterns/custom-validation.md
.orchestre/patterns/error-handling.md

3. Template Extensions

Add template-specific resources:

.orchestre/templates/custom-components.json
.orchestre/templates/integration-guides.md

Resource Lifecycle

1. Creation: Resources are created by:

   • Orchestre commands during execution
   • Manual creation by developers
   • Discovery from existing code

2. Updates: Resources are updated:

   • After task completion
   • During documentation commands
   • Through manual edits

3. Access: Resources are accessed:

   • Automatically by prompts
   • Through MCP resource API
   • By developers for reference

4. Maintenance: Resources should be:

   • Reviewed periodically
   • Updated when patterns change
   • Pruned when obsolete

Best Practices

1. Keep Resources Current: Update resources as the project evolves
2. Use Consistent Formatting: Follow template structures
3. Link Related Resources: Reference other resources when relevant
4. Version Control: Commit resource files with code changes
5. Document Decisions: Explain why patterns were chosen

Troubleshooting

Resource Not Found

• Check URI spelling and format
• Ensure resource file exists
• Verify file permissions

Outdated Resources

• Run /orchestre-discover-context to refresh
• Manually update resource files
• Check last modified dates

Resource Conflicts

• Review and merge conflicting information
• Document decision in ADR
• Update affected resources

Performance Issues

• Limit resource size to essential information
• Use specific URIs instead of wildcards
• Cache frequently accessed resources