Integration Patterns

Context patterns for framework integration and tool coordination

✅ Status: Current - Context patterns for framework integration and tool coordination.

Context Integration Guide: Patterns for using GemBoost commands effectively with different frameworks and tools. Remember: GemBoost provides context to Gemini Cli - all actual work is done by Gemini.

Overview and Usage Guide

Purpose: Effective patterns for using GemBoost context with various development frameworks and tools.

What This Is

Command combinations and flag patterns that work well for specific technologies

What This Isn't

Performance optimization or parallel execution (no code runs)

Key Principle

GemBoost tells Gemini Cli WHAT to do and HOW to think about it. Gemini Cli does the actual work.

Framework Context Patterns

React Development Patterns

# React development with appropriate context
/gb:implement "React 18 application with TypeScript" --c7
# Context7 MCP can provide React documentation if available
# Magic MCP can help with UI components if configured

# What Actually Happens:
# 1. Gemini reads implement.md for implementation patterns
# 2. --c7 flag suggests using Context7 MCP for documentation
# 3. Gemini generates React code based on these contexts

# Component development pattern
@agent-frontend-architect "design component architecture"
/gb:implement "reusable component library"

# Testing pattern for React
/gb:test --focus react
# Gemini will suggest React Testing Library patterns

Node.js Backend Patterns

# Node.js backend development patterns
/gb:implement "Express.js API with TypeScript" --c7
# Gemini will create Express API following Node.js patterns

# What This Means:
# - Gemini reads context about backend patterns
# - Suggests appropriate middleware and structure
# - NOT running or optimizing any code

# Database integration pattern
/gb:implement "database models with Prisma"
@agent-backend-architect "review database schema"

# API testing pattern
/gb:test --focus api
# Gemini suggests API testing approaches

Python Development Patterns

# Python web development
/gb:implement "FastAPI application" --c7
@agent-python-expert "review implementation"

# What Happens:
# - Gemini uses Python-specific context
# - Follows FastAPI patterns from context
# - Generates code (doesn't run it)

# Data science context
/gb:implement "data analysis pipeline"
@agent-python-expert "optimize pandas operations"
# Gemini provides optimization suggestions (not actual optimization)

# Testing patterns
/gb:test --focus python
# Gemini suggests pytest patterns

Full-Stack Development Patterns

# Full-stack application pattern
/gb:brainstorm "full-stack application architecture"
@agent-system-architect "design system components"

# Frontend implementation
/gb:implement "React frontend with TypeScript"
@agent-frontend-architect "review component structure"

# Backend implementation
/gb:implement "Node.js API with authentication"
@agent-backend-architect "review API design"

# Integration
/gb:implement "connect frontend to backend API"

Tool Coordination Patterns

Using MCP Servers Effectively

# Context7 for documentation
/gb:explain "React hooks" --c7
# If Context7 is configured, it may fetch React docs

# Sequential for complex reasoning
/gb:troubleshoot "complex bug" --seq
# Sequential MCP helps with structured problem-solving

# Magic for UI components
/gb:implement "UI components" --magic
# Magic MCP can help generate modern UI patterns

# No MCP for simple tasks
/gb:implement "utility function" --no-mcp
# Uses only Gemini's built-in knowledge

Agent and Command Combinations

# Security-focused development
@agent-security "review authentication requirements"
/gb:implement "secure authentication system"
/gb:analyze --focus security

# Quality-focused workflow
/gb:implement "new feature"
@agent-quality-engineer "review code quality"
/gb:test --focus quality

# Architecture-focused approach
@agent-system-architect "design microservices"
/gb:design "service boundaries"
/gb:implement "service communication"

Common Integration Patterns

API Development Pattern

# Step 1: Design
/gb:design "REST API structure"

# Step 2: Implementation
/gb:implement "API endpoints with validation"

# Step 3: Documentation
/gb:document --type api

# Step 4: Testing
/gb:test --focus api

Database Integration Pattern

# Schema design
@agent-backend-architect "design database schema"

# Model implementation
/gb:implement "database models"

# Migration creation
/gb:implement "database migrations"

# Query optimization suggestions
@agent-backend-architect "suggest query optimizations"
# Note: Gemini suggests optimizations, doesn't actually optimize

Testing Strategy Pattern

# Test planning
/gb:design "testing strategy"

# Unit tests
/gb:test --type unit

# Integration tests
/gb:test --type integration

# E2E test suggestions
/gb:test --type e2e
# Gemini provides test code, not execution

Technology-Specific Patterns

React + TypeScript Pattern

# Project setup guidance
/gb:implement "React TypeScript project structure"

# Component development
/gb:implement "TypeScript React components with props validation"

# State management
@agent-frontend-architect "recommend state management approach"
/gb:implement "state management with Zustand/Redux"

# Testing
/gb:test --focus react --type unit

Python FastAPI Pattern

# API structure
/gb:implement "FastAPI project structure"

# Endpoint development
@agent-python-expert "implement async endpoints"

# Database integration
/gb:implement "SQLAlchemy models with Alembic"

# Testing
/gb:test --focus python --type integration

Node.js Microservices Pattern

# Architecture design
@agent-system-architect "design microservices architecture"

# Service implementation
/gb:implement "user service with Express"
/gb:implement "auth service with JWT"

# Inter-service communication
/gb:implement "service communication patterns"

# Testing approach
/gb:test --focus microservices

Troubleshooting Patterns

Debugging Workflow

# Problem analysis
/gb:troubleshoot "describe the issue"

# Root cause investigation
@agent-root-cause-analyst "analyze symptoms"

# Solution implementation
/gb:implement "fix based on analysis"

# Verification
/gb:test --validate

Code Review Pattern

# Code analysis
/gb:analyze code/ --focus quality

# Security review
@agent-security "review for vulnerabilities"

# Performance review
@agent-performance-engineer "suggest improvements"
# Note: Suggestions only, no actual performance measurement

# Implementation of improvements
/gb:improve code/ --fix

Important Clarifications

What These Patterns DO

  • ✅Provide structured approaches to development tasks
  • ✅Combine commands and agents effectively
  • ✅Suggest appropriate tools and frameworks
  • ✅Guide Gemini to generate better code

What These Patterns DON'T DO

  • ❌Execute code or measure performance
  • ❌Run tests or deploy applications
  • ❌Optimize actual execution speed
  • ❌Provide real monitoring or metrics
  • ❌Coordinate parallel processes (everything is sequential text)

Best Practices

Effective Pattern Usage

  1. Start with context: Use /gb:load to establish project understanding
  2. Layer expertise: Combine general commands with specific agents
  3. Focus appropriately: Use --focus flags for targeted results
  4. Manage scope: Work on specific modules rather than entire codebases
  5. Document decisions: Use /gb:save to create summaries

Pattern Selection

  • Simple tasks: Use basic commands without MCP
  • Complex tasks: Add appropriate agents and MCP servers
  • Security-critical: Always include @agent-security
  • UI development: Consider --magic flag if configured
  • Documentation needs: Use --c7 for framework docs

Summary

These integration patterns show how to combine GemBoost commands, agents, and flags effectively for different development scenarios. Remember that all patterns are about providing better context to Gemini Cli - the actual code generation, not execution, is what Gemini does based on these contexts.