name: code-architect
description: Expert software architect using ALL MCP servers. Uses Memory for patterns, UltraThink for design decisions, Context7 for best practices, and MongoDB for data modeling.

🏗️ Code Architect Skill (Full MCP Integration)

Master software architect using ALL 11 MCP servers.

MCP Architecture Arsenal

Advanced Architecture Patterns

1. Architecture Decision Records (ADR) with MCP

await mcp_UltraThink_ultrathink({
  thought: `
    # ADR-${number}: ${title}

    ## Status
    Proposed

    ## Context
    ${context}

    ## Decision Drivers
    1. ${driver1}
    2. ${driver2}
    3. ${driver3}

    ## Considered Options

    ### Option A: ${optionA}
    - Pros: ...
    - Cons: ...
    - Effort: ...

    ### Option B: ${optionB}
    - Pros: ...
    - Cons: ...
    - Effort: ...

    ## Decision
    We choose Option ${chosen} because...

    ## Consequences
    - Positive: ...
    - Negative: ...
    - Risks: ...
  `,
  total_thoughts: 25,
  confidence: 0.85,
  assumptions: [
    { id: "A1", text: "Requirements are stable", critical: true },
    { id: "A2", text: "Team has X expertise", critical: false }
  ]
});

// Save to Memory
await mcp_Memory_create_entities([{
  name: `ADR_${number}_${title}`,
  entityType: "Decision",
  observations: [summary, rationale, consequences]
}]);

// Save to Notion
await mcp_Notion_API-post-page({
  parent: { database_id: adrDatabaseId },
  properties: { title: [{ text: { content: `ADR-${number}: ${title}` } }] }
});

2. Pattern Discovery & Application

// Check Memory for existing patterns
const existingPatterns = await mcp_Memory_search_nodes(
  `pattern ${domain}`
);

// Research current best practices
const [docs, web] = await Promise.all([
  mcp_Context7_query-docs(frameworkId, "architecture patterns"),
  mcp_Brave_brave_web_search(`${domain} architecture patterns 2026`)
]);

// Synthesize with UltraThink
await mcp_UltraThink_ultrathink({
  thought: `
    # Pattern Analysis for ${domain}

    ## Existing Patterns (Memory)
    ${existingPatterns.map(p => `- ${p.name}: ${p.description}`)}

    ## Framework Recommendations
    ${docs.patterns}

    ## Modern Practices (2026)
    ${web.trends}

    ## Recommended Pattern
    ${recommendation}

    ## Implementation Guide
    1. ...
  `,
  total_thoughts: 20
});

3. Data Modeling with MongoDB

// Analyze existing schema
const currentSchema = await mcp_MongoDB_collection-schema(
  database, 
  collection,
  { sampleSize: 100 }
);

// Design new schema with UltraThink
await mcp_UltraThink_ultrathink({
  thought: `
    # Data Model Design

    ## Current State
    ${JSON.stringify(currentSchema, null, 2)}

    ## Requirements
    - ${requirement1}
    - ${requirement2}

    ## Proposed Schema
    \`\`\`json
    ${proposedSchema}
    \`\`\`

    ## Index Strategy
    - Primary: ...
    - Secondary: ...
    - Composite: ...

    ## Migration Plan
    1. ...
  `,
  total_thoughts: 20
});

// Store decision in Memory
await mcp_Memory_create_entities([{
  name: `DataModel_${collection}`,
  entityType: "DataModel",
  observations: [schema, indexStrategy, rationale]
}]);

4. Component Design with SequentialThinking

await mcp_SequentialThinking_sequentialthinking({
  thought: `
    # Component Design: ${componentName}

    ## Step 1: Responsibility Definition
    - Single responsibility: ...
    - Interface boundaries: ...

    ## Step 2: Dependency Analysis
    - Depends on: ...
    - Depended by: ...
    - Coupling level: ...

    ## Step 3: Public Interface
    - Methods: ...
    - Events: ...
    - Configuration: ...

    ## Step 4: Internal Structure
    - Subcomponents: ...
    - State management: ...
    - Error handling: ...

    ## Step 5: Testing Strategy
    - Unit tests: ...
    - Integration tests: ...
    - Edge cases: ...
  `,
  thoughtNumber: 1,
  totalThoughts: 5
});

5. Cross-Cutting Concerns Analysis

await mcp_UltraThink_ultrathink({
  thought: `
    # Cross-Cutting Concerns for ${system}

    ## Logging
    - Strategy: Structured JSON
    - Levels: error, warn, info, debug
    - Correlation: Request ID propagation
    - Implementation: ...

    ## Error Handling
    - Strategy: Result types with error union
    - Recovery: Circuit breaker pattern
    - Reporting: ...

    ## Security
    - Authentication: ...
    - Authorization: ...
    - Input validation: ...

    ## Performance
    - Caching strategy: ...
    - Query optimization: ...
    - Resource pooling: ...

    ## Observability
    - Metrics: ...
    - Tracing: ...
    - Alerting: ...
  `,
  total_thoughts: 25
});

Secret Architecture Techniques

1. Architecture Knowledge Graph

// Build rich architecture knowledge
await mcp_Memory_create_entities([
  {
    name: "Component_UserService",
    entityType: "Component",
    observations: [
      "Responsibility: User management",
      "Pattern: Repository + Service",
      "Dependencies: Database, Cache, AuthService",
      "API: REST + GraphQL"
    ]
  },
  {
    name: "Pattern_CQRS",
    entityType: "Pattern",
    observations: [
      "Use case: Separate read/write",
      "Benefits: Scalability, optimization",
      "Complexity: Higher than CRUD"
    ]
  }
]);

await mcp_Memory_create_relations([
  { from: "Component_UserService", to: "Pattern_Repository", relationType: "implements" },
  { from: "Component_UserService", to: "Component_AuthService", relationType: "depends_on" }
]);

2. Architecture Evolution Tracking

// Track architecture changes over time
await mcp_Memory_add_observations([{
  entityName: "System_Architecture",
  contents: [
    `[${date}] Added: ${newComponent}`,
    `[${date}] Changed: ${modification}`,
    `[${date}] Deprecated: ${deprecated}`
  ]
}]);

3. Pattern Reuse Detection

// Find reusable patterns from other projects
const allPatterns = await mcp_Memory_search_nodes("Pattern");
const applicable = allPatterns.filter(p =>
  p.observations.some(o => 
    o.includes(currentRequirement) || o.includes(currentDomain)
  )
);

console.log("Reusable patterns:", applicable);

4. Deep Framework Research

// Before major decisions - deep research
const research = await mcp_NotebookLM_ask_question(
  `What are the architectural trade-offs of ${approach}?
   What are common pitfalls?
   What are success patterns?`,
  architectureNotebookId
);

const analysis = await mcp_UltraThink_ultrathink({
  thought: `Given research: ${research}. Applying to our context...`,
  total_thoughts: 20
});

5. Documentation Generation

// Auto-generate architecture docs
const components = await mcp_Memory_search_nodes("Component");
const patterns = await mcp_Memory_search_nodes("Pattern");
const decisions = await mcp_Memory_search_nodes("Decision");

// Create Notion page
await mcp_Notion_API-post-page({
  parent: { page_id: archDocsPageId },
  properties: { title: [{ text: { content: "Architecture Overview" } }] },
  children: [
    { type: "heading_1", heading_1: { rich_text: [{ text: { content: "Components" } }] } },
    ...components.map(c => ({
      type: "bulleted_list_item",
      bulleted_list_item: { rich_text: [{ text: { content: c.name } }] }
    })),
    { type: "heading_1", heading_1: { rich_text: [{ text: { content: "Patterns" } }] } },
    ...patterns.map(p => ({
      type: "bulleted_list_item",
      bulleted_list_item: { rich_text: [{ text: { content: p.name } }] }
    }))
  ]
});

6. Scalability Analysis

await mcp_UltraThink_ultrathink({
  thought: `
    # Scalability Analysis: ${system}

    ## Current Capacity
    - Users: ${currentUsers}
    - Requests/sec: ${currentRPS}
    - Data size: ${currentDataSize}

    ## Growth Projections
    - 6 months: ${projection6m}
    - 1 year: ${projection1y}
    - 3 years: ${projection3y}

    ## Bottleneck Analysis
    1. Database: ${dbBottleneck}
    2. API: ${apiBottleneck}
    3. Cache: ${cacheBottleneck}

    ## Scaling Strategy
    - Vertical: ...
    - Horizontal: ...
    - Sharding: ...

    ## Cost Analysis
    ${costAnalysis}
  `,
  total_thoughts: 30,
  confidence: 0.8
});