convez.ai
MCP ServerProdutividadeAvançado
yamilequintana

AI Prompt Architect: Framework de Inteligência Estruturada

yamilequintana/claude-workflow-blueprints

Framework arquitetural para prompts estruturados e reutilizáveis

Ver no GitHub
InicialPluginScore · de 0 a 100

Sistema metodológico para construir, testar e implantar blueprints de conversação que produzem saídas consistentes em Claude, GPT-4 e outros LLMs. Transforma interações fragmentadas em um fluxo disciplinado com otimização de contexto, validação de resposta e mecanismo adaptativo de retry.

Instalação

$npx convez-ai yamilequintana/claude-workflow-blueprints

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 6 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Construir biblioteca de prompts modular e reutilizável
  • Padronizar workflows de IA para equipes técnicas
  • Otimizar janelas de contexto e validar saídas de LLMs
  • Implementar pipelines robustos com fallback e retry automático

Veredito

Posiciona-se como framework arquitetural completo, mas carece de evidência concreta de implementação funcional (código, integração real com APIs). A documentação é ambiciosa em escopo, porém o repositório parece ser primariamente um guia teórico e coleção de prompts curados, não um MCP server operacional.

README

A tradução para o português deste README ainda está na fila.

AI Prompt Architect: The Structured Intelligence Framework for Claude and GPT Models

Download

Transform your AI interactions from fragmented experiments into a disciplined system of reproducible intelligence. AI Prompt Architect is not another prompt collection—it is an architectural methodology for building, testing, and deploying conversation blueprints that produce consistent, high-quality outputs across Claude, GPT-4, and other large language models.


Table of Contents


The Philosophy Behind AI Prompt Architect

Imagine building a house without blueprints—each room improvised, walls leaning, doors that open into closets. That is how most people interact with AI today. AI Prompt Architect provides the structural engineering for your AI conversations.

Why this exists: The ClaudeSkills repository demonstrated that curated prompts enhance productivity. This repository takes that premise further: instead of giving you fish, it teaches you to build fishing nets that catch different species depending on ocean conditions. You do not just download prompts; you learn to architect them for reliability, scalability, and emotional resonance.

The central insight: AI models respond to structure, not randomness. By applying architectural principles—foundations, load-bearing walls, escape routes—you create prompts that survive model updates, context window changes, and shifting use cases.


System Architecture Overview

graph TD
    A[User Input Layer] --> B[Intent Parser]
    B --> C{Routing Decision}
    C --> D[Claude API Pipeline]
    C --> E[OpenAI API Pipeline]
    C --> F[Local Model Pipeline]
    D --> G[Prompt Blueprint Engine]
    E --> G
    F --> G
    G --> H[Context Window Optimizer]
    H --> I[Response Synthesizer]
    I --> J[Output Validator]
    J --> K{Validation Pass?}
    K -->|Yes| L[Structured Output]
    K -->|No| M[Fallback Handler]
    M --> N[Adaptive Retry Mechanism]
    N --> G
    L --> O[User Interface Delivery]
    O --> P[Feedback Loop Collector]
    P --> B

This architecture ensures every prompt executes through a verified pipeline, from intent recognition to validated output. The feedback loop continuously improves prompt performance without manual intervention.


Core Components

1. Prompt Blueprint Engine

The heart of the system. Each blueprint contains:

  • Foundation Layer: System instructions that establish model persona and constraints
  • Structural Beams: Variable injection points for dynamic content
  • Reinforcement Bars: Edge case handling and error recovery protocols
  • Facade Layer: Output formatting specifications

2. Context Window Optimizer

Prevents token waste by automatically pruning redundant context while preserving semantic meaning. Compatible with Claude 100k and GPT-4 Turbo context windows.

3. Multi-Model Router

Seamlessly switches between Claude API, OpenAI API, and local models based on:

  • Task complexity
  • Cost optimization
  • Latency requirements
  • Model availability

4. Output Validator

Checks generated responses against:

  • Factual accuracy (via RAG verification)
  • Format compliance
  • Tone consistency
  • Length constraints

Feature Matrix

FeatureAI Prompt ArchitectTraditional Prompt LibrariesRaw Model Usage
Reproducible OutputsFullPartialNone
Cross-Model CompatibilityAutomatedManualN/A
Context OptimizationDynamicStaticNone
Error RecoveryAdaptiveNoneManual retry
Multilingual Support47 languages5-10 languagesVariable
Performance AnalyticsBuilt-inExternal toolsNone
Version ControlGit-nativeNoneNone

Operating System Compatibility

Operating SystemClaude CLIOpenAI CLILocal ModelsUI Dashboard
🟢 Windows 10/11FullFullFullFull
🟢 macOS Ventura+FullFullFullFull
🟢 Ubuntu 22.04+FullFullFullFull
🟡 Red Hat EnterpriseFullFullPartialFull
🟢 Debian 12+FullFullFullFull
🟡 FreeBSDPartialFullNonePartial
🔴 Android TermuxPartialPartialNoneNone

Legend: 🟢 Full support | 🟡 Partial support | 🔴 Not supported


Getting Started: Your First Prompt Blueprint

Download the starter kit: Download

  1. Clone the repository
  2. Install dependencies using the bootstrap script
  3. Run init-blueprint --mode wizard for guided setup
  4. Test with the included sample prompts

System Requirements (2026 Edition):

  • Python 3.12+ or Node.js 22+
  • 4GB RAM minimum (8GB recommended for local models)
  • 500MB disk space for prompt templates
  • Internet connection for API integrations

Configuration Examples

Basic Profile Configuration (YAML)

profile:
  name: "Technical Writing Assistant"
  model_preference: claude-3-5-sonnet
  temperature: 0.3
  max_tokens: 4096
  multilingual:
    primary: en
    fallback: zh
    translation_service: deepseek
  responsive_ui:
    theme: solarized-dark
    breakpoints:
      mobile: 480px
      tablet: 768px
      desktop: 1200px
  support_24_7:
    chatbot_enabled: true
    escalation_threshold: 3
    human_handoff_webhook: https://api.example.com/handoff

Advanced Profile Configuration (JSON with API Keys)

{
  "profile": "Data Analyst",
  "api_integration": {
    "claude_api": {
      "endpoint": "https://api.anthropic.com/v1/messages",
      "model": "claude-3-5-sonnet-20261002",
      "max_retries": 3
    },
    "openai_api": {
      "endpoint": "https://api.openai.com/v1/chat/completions",
      "model": "gpt-4-turbo-2026",
      "fallback": "gpt-3.5-turbo"
    }
  },
  "context_window": {
    "strategy": "sliding",
    "reserved_tokens": 500,
    "compression_ratio": 0.7
  }
}

Console Invocation Patterns

Basic Invocation

prompt-architect run --blueprint technical-writer --input-document ./article.md

Multi-Model Comparison

prompt-architect compare \
  --blueprint sentiment-analysis \
  --models claude-3-sonnet,gpt-4,local-llama \
  --test-set ./evaluation/samples.json \
  --output-format html

Continuous Monitoring Mode

prompt-architect serve \
  --port 8080 \
  --log-level info \
  --metrics-endpoint prometheus:9090 \
  --health-check-interval 30

API Integration Guide

Claude API Integration

AI Prompt Architect wraps Claude API calls with:

  • Automatic retry with exponential backoff
  • Context window monitoring
  • Response parsing with error correction
  • Token usage tracking per session

Example integration:

from prompt_architect import ClaudeConnector

claude = ClaudeConnector(
    api_key=os.getenv("ANTHROPIC_API_KEY"),
    model="claude-3-5-sonnet-20261002",
    safety_mode="strict"
)

response = claude.execute(
    blueprint="code-reviewer",
    variables={"language": "python", "style": "pep8"},
    temperature=0.2
)

OpenAI API Integration

Similar wrapper pattern with GPT-4 Turbo optimization:

from prompt_architect import OpenAIConnector

gpt = OpenAIConnector(
    api_key=os.getenv("OPENAI_API_KEY"),
    organization=os.getenv("OPENAI_ORG_ID"),
    default_model="gpt-4-turbo-2026"
)

stream = gpt.stream_response(
    blueprint="creative-writer",
    variables={"genre": "cyberpunk", "tone": "noir"},
    stream=True
)

Multilingual Support Architecture

AI Prompt Architect supports 47 languages through a three-tier translation system:

  1. Direct Model Capability: Leverages native multilingual abilities of Claude and GPT
  2. Translation Bridge: Uses dedicated translation APIs (DeepL, Google Translate, Microsoft Translator)
  3. Fallback Chain: Automatically degrades through tiers if primary fails

Language detection uses a combination of:

  • FastText-based classification
  • Unicode range analysis
  • N-gram probability scoring

Responsive UI Components

The dashboard adapts to any screen size through CSS Grid and container queries:

ComponentMobile (<768px)Tablet (768-1200px)Desktop (>1200px)
Blueprint EditorSingle columnTwo columnsThree columns
Output PreviewCollapsedSide panelFull width
Metrics DashboardHiddenSummary cardsFull graphs
API ConsoleBottom sheetRight panelDedicated tab

24/7 Support Framework

The support system operates on three layers:

  1. Automated Tier (Immediate):

    • Contextual help popups
    • Blueprint validation suggestions
    • Error message explanation with fixes
  2. Community Tier (Under 1 hour):

    • Built-in forum integration
    • Peer review system for blueprints
    • Shared troubleshooting database
  3. Expert Tier (Scheduled):

    • AI-assisted human support agents
    • Screen sharing capability
    • Blueprint performance audit

Mermaid Diagram: Prompt Execution Flow

sequenceDiagram
    participant User
    participant CLI as CLI Interface
    participant Router as Model Router
    participant Claude as Claude API
    participant OpenAI as OpenAI API
    participant Validator as Output Validator
    participant Cache as Response Cache

    User->>CLI: Invoke prompt-architect run
    CLI->>Router: Parse blueprint & variables
    Router->>Router: Check availability & cost
    alt Claude preferred
        Router->>Claude: Execute blueprint
        Claude-->>Router: Raw response
    else OpenAI fallback
        Router->>OpenAI: Execute blueprint
        OpenAI-->>Router: Raw response
    end
    Router->>Validator: Validate structure & content
    Validator->>Cache: Check for duplicates
    alt Validation passed
        Validator-->>CLI: Formatted output
        CLI-->>User: Display result
    else Validation failed
        Validator->>Router: Request retry with adjusted params
        Router->>Claude: Retry with temperature+0.1
        Claude-->>Router: Corrected response
        Router->>Validator: Verify again
        Validator-->>CLI: Final output
        CLI-->>User: Display result with warning
    end
    User->>CLI: Provide feedback (thumb up/down)
    CLI->>Cache: Update performance metrics

Security and Privacy Considerations

  • API keys stored in encrypted environment vaults
  • Prompt blueprints support variable redaction for sensitive data
  • Local execution mode for air-gapped environments
  • Audit logging tracks all API calls without storing content

Contributing to the Architecture

We welcome blueprint architects, prompt engineers, and AI enthusiasts. Contribution guidelines:

  1. Fork the repository
  2. Create a feature branch
  3. Add your blueprint following the template in /templates
  4. Include test cases in /tests
  5. Submit a pull request with screenshots of outputs

Blueprint quality criteria:

  • Must work with at least two model families
  • Must include edge case handling
  • Must document token consumption
  • Must pass automated validation

License

This project is licensed under the MIT License - see the LICENSE file for details.

Copyright (c) 2026 AI Prompt Architect Contributors

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files...


Disclaimer

Important: This repository provides architectural frameworks and prompt engineering methodologies. It does not guarantee specific outputs from AI models. AI behavior can vary based on model updates, context windows, and input quality.

  • The creators are not responsible for outputs that violate terms of service of third-party APIs
  • Users must comply with Anthropic, OpenAI, and other API providers' usage policies
  • Some features require API keys and paid subscriptions
  • The 2026 date references planned compatibility; actual model availability may differ

Use at your own discretion. AI Prompt Architect is a tool like any architectural blueprint—it enables construction but does not guarantee a perfect building.


Download

Download

https://yamilequintana.github.io — Direct download of the complete repository with examples, templates, and documentation.

AI Prompt Architect: Build intelligence with structure, not luck.

Ver o original no GitHub

Bom para

Relacionados