flowchart LR
    A["Task Input"] --> B["Category Detection"]
    B --> C["Complexity Scoring"]
    C --> D["Intent Analysis"]
    D --> E["Framework Selection"]
    E --> F["Meta-Prompt Generation"]

    style A fill:#1a1a2e,stroke:#e94560,color:#fff
    style B fill:#1a1a2e,stroke:#0f3460,color:#fff
    style C fill:#1a1a2e,stroke:#0f3460,color:#fff
    style D fill:#1a1a2e,stroke:#0f3460,color:#fff
    style E fill:#1a1a2e,stroke:#e94560,color:#fff
    style F fill:#1a1a2e,stroke:#16c79a,color:#fff

from promptcore.domain import FrameworkSelector, PromptBuilder

selector = FrameworkSelector()
analysis = selector.analyze("Write a recursive function to calculate fibonacci numbers")

print(analysis.category)               # CODE
print(analysis.complexity_score)       # 3.3
print(analysis.recommended_framework)  # program_of_thoughts

Task: "Write a recursive function to calculate fibonacci numbers"

  Category:    CODE
  Complexity:  3.3 / 10
  Framework:   Program of Thoughts
  Meta-prompt:
    "Approach this problem by expressing your reasoning as executable code.
     Break the task into computational steps:
     1. Define the problem as a function signature
     2. Identify the base cases and recursive structure
     3. Express the logic as working code with comments explaining each decision
     4. Verify correctness by tracing through example inputs
     ..."

graph TB
    subgraph ZS["Zero-Shot"]
        zs1["Role Prompting"]
        zs2["Emotion Prompting"]
        zs3["System-2 Attention"]
        zs4["SimToM"]
        zs5["Rephrase & Respond"]
        zs6["Self-Ask"]
    end

    subgraph TG["Thought Generation"]
        tg1["Chain of Thought"]
        tg2["Step-Back"]
        tg3["Thread of Thought"]
        tg4["Tab-CoT"]
        tg5["Contrastive CoT"]
        tg6["Complexity-Based"]
        tg7["Active Prompting"]
        tg8["Analogical"]
        tg9["Directional Stimulus"]
    end

    subgraph DC["Decomposition"]
        dc1["Tree of Thoughts"]
        dc2["Least-to-Most"]
        dc3["Program of Thoughts"]
        dc4["Skeleton of Thought"]
        dc5["Plan-and-Solve"]
        dc6["Faithful CoT"]
        dc7["Recursion of Thought"]
    end

    subgraph EN["Ensembling"]
        en1["Self-Consistency"]
        en2["DENSE"]
        en3["MoRE"]
        en4["Meta-CoT"]
        en5["Prompt Paraphrasing"]
    end

    subgraph SC["Self-Criticism"]
        sc1["Reflexion"]
        sc2["Maieutic"]
        sc3["Chain of Verification"]
        sc4["Self-Refine"]
        sc5["Self-Calibration"]
        sc6["Reverse CoT"]
        sc7["Cumulative Reasoning"]
    end

    subgraph AD["Advanced"]
        ad1["ReAct"]
        ad2["Graph of Thoughts"]
        ad3["Reasoning via Planning"]
        ad4["Chain of Density"]
        ad5["Buffer of Thoughts"]
        ad6["Chain of Table"]
    end

    style ZS fill:#0d1117,stroke:#58a6ff,color:#c9d1d9
    style TG fill:#0d1117,stroke:#f0883e,color:#c9d1d9
    style DC fill:#0d1117,stroke:#a371f7,color:#c9d1d9
    style EN fill:#0d1117,stroke:#3fb950,color:#c9d1d9
    style SC fill:#0d1117,stroke:#f85149,color:#c9d1d9
    style AD fill:#0d1117,stroke:#d2a8ff,color:#c9d1d9

graph TB
    MCP["MCP Interface<br/><code>main.py</code>"] --> Domain

    subgraph Domain["Domain Layer"]
        Selector["FrameworkSelector<br/><code>selector.py</code>"]
        Frameworks["Framework Registry<br/><code>frameworks.py</code><br/>40 implementations"]
        Builder["PromptBuilder<br/><code>builder.py</code>"]
        Selector --> Frameworks
        Frameworks --> Builder
    end

    subgraph Persistence["Persistence Layer"]
        Models["SQLAlchemy Models<br/><code>models.py</code>"]
        Storage["SQLite Storage<br/><code>storage.py</code>"]
        Models --> Storage
    end

    subgraph Utils["Utilities"]
        Complexity["Complexity Analyzer<br/><code>complexity.py</code>"]
    end

    Domain --> Persistence
    Selector --> Complexity

    style MCP fill:#1a1a2e,stroke:#e94560,color:#fff
    style Domain fill:#0d1117,stroke:#58a6ff,color:#c9d1d9
    style Persistence fill:#0d1117,stroke:#3fb950,color:#c9d1d9
    style Utils fill:#0d1117,stroke:#f0883e,color:#c9d1d9

src/promptcore/
├── main.py              # MCP server entry point (FastMCP, stdio transport)
├── domain/
│   ├── frameworks.py    # 40 reasoning framework implementations
│   ├── selector.py      # Task analysis: category, complexity, intent, framework scoring
│   └── builder.py       # Meta-prompt assembly from framework templates
├── persistence/
│   ├── models.py        # SQLAlchemy + Pydantic models (ReasoningLog)
│   └── storage.py       # SQLite operations for traces and analytics
└── utils/
    └── complexity.py    # Text complexity analysis (token count, keywords, ambiguity)

# 1. Clone
git clone https://github.com/BlinkVoid/PromptCore.git
cd PromptCore

# 2. Install dependencies
uv sync

# 3. Run the MCP server
uv run python -m promptcore.main

{
  "mcpServers": {
    "promptcore": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/PromptCore", "python", "-m", "promptcore.main"],
      "env": {
        "PYTHONPATH": "/path/to/PromptCore/src",
        "UV_LINK_MODE": "copy",
        "FASTMCP_SHOW_STARTUP_BANNER": "false"
      }
    }
  }
}

{
  "mcpServers": {
    "promptcore": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/PromptCore", "python", "-m", "promptcore.main"],
      "env": {
        "PYTHONPATH": "/path/to/PromptCore/src"
      }
    }
  }
}

# Any MCP client can call PromptCore as a tool
result = mcp_call("promptcore", "generate_meta_prompt", {
    "task": "Analyze the trade-offs between microservices and monolith for a fintech startup",
    "context": "The team has 4 engineers and needs to ship in 3 months"
})

# Feed the optimized prompt to any LLM
response = llm.generate(result["meta_prompt"])

from promptcore.domain import FrameworkSelector, PromptBuilder

selector = FrameworkSelector()
builder = PromptBuilder()

# Analyze
analysis = selector.analyze("Design a distributed cache invalidation strategy")
print(f"Category: {analysis.category}")                # PLANNING
print(f"Complexity: {analysis.complexity_score}")       # ~7.2
print(f"Framework: {analysis.recommended_framework}")   # reasoning_via_planning

# Generate
result = builder.build(analysis.task, analysis=analysis)
print(result.meta_prompt)  # Structured prompt using Reasoning-via-Planning methodology

# Middleware pattern: enhance every LLM call with optimal reasoning
def enhanced_llm_call(task: str, context: str = "") -> str:
    # Step 1: Get optimal reasoning strategy
    strategy = mcp_call("promptcore", "recommend_strategy", {"task": task})

    # Step 2: Generate meta-prompt
    prompt = mcp_call("promptcore", "generate_meta_prompt", {
        "task": task,
        "context": context,
        "framework": strategy["recommended_framework"]
    })

    # Step 3: Execute with any LLM
    result = llm.generate(prompt["meta_prompt"])

    # Step 4: Log feedback for analytics
    mcp_call("promptcore", "log_execution_feedback", {
        "log_id": prompt["log_id"],
        "feedback": "success",
        "notes": "Output matched expected format"
    })

    return result