skill-library-mcp 1.0.0

package/skills/context-fundamentals/SKILL.md

@@ -0,0 +1,192 @@
+---
+name: context-fundamentals
+description: "Understand what context is, why it matters, and the anatomy of context in agent systems"
+source: "https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering/tree/main/skills/context-fundamentals"
+risk: safe
+---
+
+## When to Use This Skill
+
+Understand what context is, why it matters, and the anatomy of context in agent systems
+
+Use this skill when working with understand what context is, why it matters, and the anatomy of context in agent systems.
+# Context Engineering Fundamentals
+
+Context is the complete state available to a language model at inference time. It includes everything the model can attend to when generating responses: system instructions, tool definitions, retrieved documents, message history, and tool outputs. Understanding context fundamentals is prerequisite to effective context engineering.
+
+## When to Activate
+
+Activate this skill when:
+- Designing new agent systems or modifying existing architectures
+- Debugging unexpected agent behavior that may relate to context
+- Optimizing context usage to reduce token costs or improve performance
+- Onboarding new team members to context engineering concepts
+- Reviewing context-related design decisions
+
+## Core Concepts
+
+Context comprises several distinct components, each with different characteristics and constraints. The attention mechanism creates a finite budget that constrains effective context usage. Progressive disclosure manages this constraint by loading information only as needed. The engineering discipline is curating the smallest high-signal token set that achieves desired outcomes.
+
+## Detailed Topics
+
+### The Anatomy of Context
+
+**System Prompts**
+System prompts establish the agent's core identity, constraints, and behavioral guidelines. They are loaded once at session start and typically persist throughout the conversation. System prompts should be extremely clear and use simple, direct language at the right altitude for the agent.
+
+The right altitude balances two failure modes. At one extreme, engineers hardcode complex brittle logic that creates fragility and maintenance burden. At the other extreme, engineers provide vague high-level guidance that fails to give concrete signals for desired outputs or falsely assumes shared context. The optimal altitude strikes a balance: specific enough to guide behavior effectively, yet flexible enough to provide strong heuristics.
+
+Organize prompts into distinct sections using XML tagging or Markdown headers to delineate background information, instructions, tool guidance, and output description. The exact formatting matters less as models become more capable, but structural clarity remains valuable.
+
+**Tool Definitions**
+Tool definitions specify the actions an agent can take. Each tool includes a name, description, parameters, and return format. Tool definitions live near the front of context after serialization, typically before or after the system prompt.
+
+Tool descriptions collectively steer agent behavior. Poor descriptions force agents to guess; optimized descriptions include usage context, examples, and defaults. The consolidation principle states that if a human engineer cannot definitively say which tool should be used in a given situation, an agent cannot be expected to do better.
+
+**Retrieved Documents**
+Retrieved documents provide domain-specific knowledge, reference materials, or task-relevant information. Agents use retrieval augmented generation to pull relevant documents into context at runtime rather than pre-loading all possible information.
+
+The just-in-time approach maintains lightweight identifiers (file paths, stored queries, web links) and uses these references to load data into context dynamically. This mirrors human cognition: we generally do not memorize entire corpuses of information but rather use external organization and indexing systems to retrieve relevant information on demand.
+
+**Message History**
+Message history contains the conversation between the user and agent, including previous queries, responses, and reasoning. For long-running tasks, message history can grow to dominate context usage.
+
+Message history serves as scratchpad memory where agents track progress, maintain task state, and preserve reasoning across turns. Effective management of message history is critical for long-horizon task completion.
+
+**Tool Outputs**
+Tool outputs are the results of agent actions: file contents, search results, command execution output, API responses, and similar data. Tool outputs comprise the majority of tokens in typical agent trajectories, with research showing observations (tool outputs) can reach 83.9% of total context usage.
+
+Tool outputs consume context whether they are relevant to current decisions or not. This creates pressure for strategies like observation masking, compaction, and selective tool result retention.
+
+### Context Windows and Attention Mechanics
+
+**The Attention Budget Constraint**
+Language models process tokens through attention mechanisms that create pairwise relationships between all tokens in context. For n tokens, this creates n² relationships that must be computed and stored. As context length increases, the model's ability to capture these relationships gets stretched thin.
+
+Models develop attention patterns from training data distributions where shorter sequences predominate. This means models have less experience with and fewer specialized parameters for context-wide dependencies. The result is an "attention budget" that depletes as context grows.
+
+**Position Encoding and Context Extension**
+Position encoding interpolation allows models to handle longer sequences by adapting them to originally trained smaller contexts. However, this adaptation introduces degradation in token position understanding. Models remain highly capable at longer contexts but show reduced precision for information retrieval and long-range reasoning compared to performance on shorter contexts.
+
+**The Progressive Disclosure Principle**
+Progressive disclosure manages context efficiently by loading information only as needed. At startup, agents load only skill names and descriptions—sufficient to know when a skill might be relevant. Full content loads only when a skill is activated for specific tasks.
+
+This approach keeps agents fast while giving them access to more context on demand. The principle applies at multiple levels: skill selection, document loading, and even tool result retrieval.
+
+### Context Quality Versus Context Quantity
+
+The assumption that larger context windows solve memory problems has been empirically debunked. Context engineering means finding the smallest possible set of high-signal tokens that maximize the likelihood of desired outcomes.
+
+Several factors create pressure for context efficiency. Processing cost grows disproportionately with context length—not just double the cost for double the tokens, but exponentially more in time and computing resources. Model performance degrades beyond certain context lengths even when the window technically supports more tokens. Long inputs remain expensive even with prefix caching.
+
+The guiding principle is informativity over exhaustiveness. Include what matters for the decision at hand, exclude what does not, and design systems that can access additional information on demand.
+
+### Context as Finite Resource
+
+Context must be treated as a finite resource with diminishing marginal returns. Like humans with limited working memory, language models have an attention budget drawn on when parsing large volumes of context.
+
+Every new token introduced depletes this budget by some amount. This creates the need for careful curation of available tokens. The engineering problem is optimizing utility against inherent constraints.
+
+Context engineering is iterative and the curation phase happens each time you decide what to pass to the model. It is not a one-time prompt writing exercise but an ongoing discipline of context management.
+
+## Practical Guidance
+
+### File-System-Based Access
+
+Agents with filesystem access can use progressive disclosure naturally. Store reference materials, documentation, and data externally. Load files only when needed using standard filesystem operations. This pattern avoids stuffing context with information that may not be relevant.
+
+The file system itself provides structure that agents can navigate. File sizes suggest complexity; naming conventions hint at purpose; timestamps serve as proxies for relevance. Metadata of file references provides a mechanism to efficiently refine behavior.
+
+### Hybrid Strategies
+
+The most effective agents employ hybrid strategies. Pre-load some context for speed (like CLAUDE.md files or project rules), but enable autonomous exploration for additional context as needed. The decision boundary depends on task characteristics and context dynamics.
+
+For contexts with less dynamic content, pre-loading more upfront makes sense. For rapidly changing or highly specific information, just-in-time loading avoids stale context.
+
+### Context Budgeting
+
+Design with explicit context budgets in mind. Know the effective context limit for your model and task. Monitor context usage during development. Implement compaction triggers at appropriate thresholds. Design systems assuming context will degrade rather than hoping it will not.
+
+Effective context budgeting requires understanding not just raw token counts but also attention distribution patterns. The middle of context receives less attention than the beginning and end. Place critical information at attention-favored positions.
+
+## Examples
+
+**Example 1: Organizing System Prompts**
+```markdown
+<BACKGROUND_INFORMATION>
+You are a Python expert helping a development team.
+Current project: Data processing pipeline in Python 3.9+
+</BACKGROUND_INFORMATION>
+
+<INSTRUCTIONS>
+- Write clean, idiomatic Python code
+- Include type hints for function signatures
+- Add docstrings for public functions
+- Follow PEP 8 style guidelines
+</INSTRUCTIONS>
+
+<TOOL_GUIDANCE>
+Use bash for shell operations, python for code tasks.
+File operations should use pathlib for cross-platform compatibility.
+</TOOL_GUIDANCE>
+
+<OUTPUT_DESCRIPTION>
+Provide code blocks with syntax highlighting.
+Explain non-obvious decisions in comments.
+</OUTPUT_DESCRIPTION>
+```
+
+**Example 2: Progressive Document Loading**
+```markdown
+# Instead of loading all documentation at once:
+
+# Step 1: Load summary
+docs/api_summary.md          # Lightweight overview
+
+# Step 2: Load specific section as needed
+docs/api/endpoints.md        # Only when API calls needed
+docs/api/authentication.md   # Only when auth context needed
+```
+
+## Guidelines
+
+1. Treat context as a finite resource with diminishing returns
+2. Place critical information at attention-favored positions (beginning and end)
+3. Use progressive disclosure to defer loading until needed
+4. Organize system prompts with clear section boundaries
+5. Monitor context usage during development
+6. Implement compaction triggers at 70-80% utilization
+7. Design for context degradation rather than hoping to avoid it
+8. Prefer smaller high-signal context over larger low-signal context
+
+## Integration
+
+This skill provides foundational context that all other skills build upon. It should be studied first before exploring:
+
+- context-degradation - Understanding how context fails
+- context-optimization - Techniques for extending context capacity
+- multi-agent-patterns - How context isolation enables multi-agent systems
+- tool-design - How tool definitions interact with context
+
+## References
+
+Internal reference:
+- [Context Components Reference](./references/context-components.md) - Detailed technical reference
+
+Related skills in this collection:
+- context-degradation - Understanding context failure patterns
+- context-optimization - Techniques for efficient context use
+
+External resources:
+- Research on transformer attention mechanisms
+- Production engineering guides from leading AI labs
+- Framework documentation on context window management
+
+---
+
+## Skill Metadata
+
+**Created**: 2025-12-20
+**Last Updated**: 2025-12-20
+**Author**: Agent Skills for Context Engineering Contributors
+**Version**: 1.0.0

package/skills/context-management-context-restore/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: context-management-context-restore
+description: "Use when working with context management context restore"
+---
+
+# Context Restoration: Advanced Semantic Memory Rehydration
+
+## Use this skill when
+
+- Working on context restoration: advanced semantic memory rehydration tasks or workflows
+- Needing guidance, best practices, or checklists for context restoration: advanced semantic memory rehydration
+
+## Do not use this skill when
+
+- The task is unrelated to context restoration: advanced semantic memory rehydration
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Role Statement
+
+Expert Context Restoration Specialist focused on intelligent, semantic-aware context retrieval and reconstruction across complex multi-agent AI workflows. Specializes in preserving and reconstructing project knowledge with high fidelity and minimal information loss.
+
+## Context Overview
+
+The Context Restoration tool is a sophisticated memory management system designed to:
+- Recover and reconstruct project context across distributed AI workflows
+- Enable seamless continuity in complex, long-running projects
+- Provide intelligent, semantically-aware context rehydration
+- Maintain historical knowledge integrity and decision traceability
+
+## Core Requirements and Arguments
+
+### Input Parameters
+- `context_source`: Primary context storage location (vector database, file system)
+- `project_identifier`: Unique project namespace
+- `restoration_mode`:
+  - `full`: Complete context restoration
+  - `incremental`: Partial context update
+  - `diff`: Compare and merge context versions
+- `token_budget`: Maximum context tokens to restore (default: 8192)
+- `relevance_threshold`: Semantic similarity cutoff for context components (default: 0.75)
+
+## Advanced Context Retrieval Strategies
+
+### 1. Semantic Vector Search
+- Utilize multi-dimensional embedding models for context retrieval
+- Employ cosine similarity and vector clustering techniques
+- Support multi-modal embedding (text, code, architectural diagrams)
+
+```python
+def semantic_context_retrieve(project_id, query_vector, top_k=5):
+    """Semantically retrieve most relevant context vectors"""
+    vector_db = VectorDatabase(project_id)
+    matching_contexts = vector_db.search(
+        query_vector,
+        similarity_threshold=0.75,
+        max_results=top_k
+    )
+    return rank_and_filter_contexts(matching_contexts)
+```
+
+### 2. Relevance Filtering and Ranking
+- Implement multi-stage relevance scoring
+- Consider temporal decay, semantic similarity, and historical impact
+- Dynamic weighting of context components
+
+```python
+def rank_context_components(contexts, current_state):
+    """Rank context components based on multiple relevance signals"""
+    ranked_contexts = []
+    for context in contexts:
+        relevance_score = calculate_composite_score(
+            semantic_similarity=context.semantic_score,
+            temporal_relevance=context.age_factor,
+            historical_impact=context.decision_weight
+        )
+        ranked_contexts.append((context, relevance_score))
+
+    return sorted(ranked_contexts, key=lambda x: x[1], reverse=True)
+```
+
+### 3. Context Rehydration Patterns
+- Implement incremental context loading
+- Support partial and full context reconstruction
+- Manage token budgets dynamically
+
+```python
+def rehydrate_context(project_context, token_budget=8192):
+    """Intelligent context rehydration with token budget management"""
+    context_components = [
+        'project_overview',
+        'architectural_decisions',
+        'technology_stack',
+        'recent_agent_work',
+        'known_issues'
+    ]
+
+    prioritized_components = prioritize_components(context_components)
+    restored_context = {}
+
+    current_tokens = 0
+    for component in prioritized_components:
+        component_tokens = estimate_tokens(component)
+        if current_tokens + component_tokens <= token_budget:
+            restored_context[component] = load_component(component)
+            current_tokens += component_tokens
+
+    return restored_context
+```
+
+### 4. Session State Reconstruction
+- Reconstruct agent workflow state
+- Preserve decision trails and reasoning contexts
+- Support multi-agent collaboration history
+
+### 5. Context Merging and Conflict Resolution
+- Implement three-way merge strategies
+- Detect and resolve semantic conflicts
+- Maintain provenance and decision traceability
+
+### 6. Incremental Context Loading
+- Support lazy loading of context components
+- Implement context streaming for large projects
+- Enable dynamic context expansion
+
+### 7. Context Validation and Integrity Checks
+- Cryptographic context signatures
+- Semantic consistency verification
+- Version compatibility checks
+
+### 8. Performance Optimization
+- Implement efficient caching mechanisms
+- Use probabilistic data structures for context indexing
+- Optimize vector search algorithms
+
+## Reference Workflows
+
+### Workflow 1: Project Resumption
+1. Retrieve most recent project context
+2. Validate context against current codebase
+3. Selectively restore relevant components
+4. Generate resumption summary
+
+### Workflow 2: Cross-Project Knowledge Transfer
+1. Extract semantic vectors from source project
+2. Map and transfer relevant knowledge
+3. Adapt context to target project's domain
+4. Validate knowledge transferability
+
+## Usage Examples
+
+```bash
+# Full context restoration
+context-restore project:ai-assistant --mode full
+
+# Incremental context update
+context-restore project:web-platform --mode incremental
+
+# Semantic context query
+context-restore project:ml-pipeline --query "model training strategy"
+```
+
+## Integration Patterns
+- RAG (Retrieval Augmented Generation) pipelines
+- Multi-agent workflow coordination
+- Continuous learning systems
+- Enterprise knowledge management
+
+## Future Roadmap
+- Enhanced multi-modal embedding support
+- Quantum-inspired vector search algorithms
+- Self-healing context reconstruction
+- Adaptive learning context strategies

package/skills/context-management-context-save/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: context-management-context-save
+description: "Use when working with context management context save"
+---
+
+# Context Save Tool: Intelligent Context Management Specialist
+
+## Use this skill when
+
+- Working on context save tool: intelligent context management specialist tasks or workflows
+- Needing guidance, best practices, or checklists for context save tool: intelligent context management specialist
+
+## Do not use this skill when
+
+- The task is unrelated to context save tool: intelligent context management specialist
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Role and Purpose
+An elite context engineering specialist focused on comprehensive, semantic, and dynamically adaptable context preservation across AI workflows. This tool orchestrates advanced context capture, serialization, and retrieval strategies to maintain institutional knowledge and enable seamless multi-session collaboration.
+
+## Context Management Overview
+The Context Save Tool is a sophisticated context engineering solution designed to:
+- Capture comprehensive project state and knowledge
+- Enable semantic context retrieval
+- Support multi-agent workflow coordination
+- Preserve architectural decisions and project evolution
+- Facilitate intelligent knowledge transfer
+
+## Requirements and Argument Handling
+
+### Input Parameters
+- `$PROJECT_ROOT`: Absolute path to project root
+- `$CONTEXT_TYPE`: Granularity of context capture (minimal, standard, comprehensive)
+- `$STORAGE_FORMAT`: Preferred storage format (json, markdown, vector)
+- `$TAGS`: Optional semantic tags for context categorization
+
+## Context Extraction Strategies
+
+### 1. Semantic Information Identification
+- Extract high-level architectural patterns
+- Capture decision-making rationales
+- Identify cross-cutting concerns and dependencies
+- Map implicit knowledge structures
+
+### 2. State Serialization Patterns
+- Use JSON Schema for structured representation
+- Support nested, hierarchical context models
+- Implement type-safe serialization
+- Enable lossless context reconstruction
+
+### 3. Multi-Session Context Management
+- Generate unique context fingerprints
+- Support version control for context artifacts
+- Implement context drift detection
+- Create semantic diff capabilities
+
+### 4. Context Compression Techniques
+- Use advanced compression algorithms
+- Support lossy and lossless compression modes
+- Implement semantic token reduction
+- Optimize storage efficiency
+
+### 5. Vector Database Integration
+Supported Vector Databases:
+- Pinecone
+- Weaviate
+- Qdrant
+
+Integration Features:
+- Semantic embedding generation
+- Vector index construction
+- Similarity-based context retrieval
+- Multi-dimensional knowledge mapping
+
+### 6. Knowledge Graph Construction
+- Extract relational metadata
+- Create ontological representations
+- Support cross-domain knowledge linking
+- Enable inference-based context expansion
+
+### 7. Storage Format Selection
+Supported Formats:
+- Structured JSON
+- Markdown with frontmatter
+- Protocol Buffers
+- MessagePack
+- YAML with semantic annotations
+
+## Code Examples
+
+### 1. Context Extraction
+```python
+def extract_project_context(project_root, context_type='standard'):
+    context = {
+        'project_metadata': extract_project_metadata(project_root),
+        'architectural_decisions': analyze_architecture(project_root),
+        'dependency_graph': build_dependency_graph(project_root),
+        'semantic_tags': generate_semantic_tags(project_root)
+    }
+    return context
+```
+
+### 2. State Serialization Schema
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "project_name": {"type": "string"},
+    "version": {"type": "string"},
+    "context_fingerprint": {"type": "string"},
+    "captured_at": {"type": "string", "format": "date-time"},
+    "architectural_decisions": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "decision_type": {"type": "string"},
+          "rationale": {"type": "string"},
+          "impact_score": {"type": "number"}
+        }
+      }
+    }
+  }
+}
+```
+
+### 3. Context Compression Algorithm
+```python
+def compress_context(context, compression_level='standard'):
+    strategies = {
+        'minimal': remove_redundant_tokens,
+        'standard': semantic_compression,
+        'comprehensive': advanced_vector_compression
+    }
+    compressor = strategies.get(compression_level, semantic_compression)
+    return compressor(context)
+```
+
+## Reference Workflows
+
+### Workflow 1: Project Onboarding Context Capture
+1. Analyze project structure
+2. Extract architectural decisions
+3. Generate semantic embeddings
+4. Store in vector database
+5. Create markdown summary
+
+### Workflow 2: Long-Running Session Context Management
+1. Periodically capture context snapshots
+2. Detect significant architectural changes
+3. Version and archive context
+4. Enable selective context restoration
+
+## Advanced Integration Capabilities
+- Real-time context synchronization
+- Cross-platform context portability
+- Compliance with enterprise knowledge management standards
+- Support for multi-modal context representation
+
+## Limitations and Considerations
+- Sensitive information must be explicitly excluded
+- Context capture has computational overhead
+- Requires careful configuration for optimal performance
+
+## Future Roadmap
+- Improved ML-driven context compression
+- Enhanced cross-domain knowledge transfer
+- Real-time collaborative context editing
+- Predictive context recommendation systems