# Directory Structure
```
├── .dockerignore
├── .gitignore
├── Dockerfile
├── license
├── pyproject.toml
├── README.md
├── requirements.txt
├── smithery.yaml
├── src
│ └── osp_marketing_tools
│ ├── __init__.py
│ ├── codes-llm.md
│ ├── guide-llm.md
│ ├── meta-llm.md
│ ├── on-page-seo-guide.md
│ ├── product-value-map-llm.md
│ └── server.py
└── uv.lock
```
# Files
--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
```
# .dockerignore file for the project
# Ignore version control files
.git/
.gitignore
# Ignore Python cache and compiled files
__pycache__/
*.pyc
*.pyo
.pytest_cache/
.coverage
# Ignore IDE and editor files
.idea/
.vscode/
*.swp
*.swo
# Ignore build and test artifacts
dist/
build/
out/
test/
tests/
*_test.go
# Ignore environment and secret files
.env*
*.env
*.pem
*.key
*.crt
config.local.*
*.local.yml
# Ignore documentation and temporary files
docs/
*.md
README*
tmp/
temp/
*.tmp
.local/
local/
# Ignore Docker-related files
Dockerfile*
docker-compose*
# Ignore project-specific files
uv.lock
```
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
```
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
dist/
build/
*.egg-info/
*.egg
# Virtual environments
venv/
env/
ENV/
.env/
.venv/
# IDE specific files
.idea/
.vscode/
*.swp
*.swo
.project
.pydevproject
.settings/
# Jupyter Notebook
.ipynb_checkpoints
*.ipynb
# Testing
.coverage
htmlcov/
.tox/
.pytest_cache/
nosetests.xml
coverage.xml
# Documentation
docs/_build/
site/
# Logs and databases
*.log
*.sqlite
*.db
# Local development settings
.env
.env.local
.env.*.local
# OS generated files
.DS_Store
.DS_Store?
._*
.Spotlight-V100
.Trashes
ehthumbs.db
Thumbs.db
# mypy
.mypy_cache/
.dmypy.json
dmypy.json
# pipenv
Pipfile.lock
# poetry
poetry.lock
```
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
```markdown
# Open Strategy Partners (OSP) Marketing Tools for LLMs
A comprehensive suite of tools for technical marketing content creation, optimization, and product positioning based on [Open Strategy Partners](https://openstrategypartners.com)' proven methodologies.
This software is based on the [Model Context Protocol (MCP)](https://openstrategypartners.com/blog/the-model-context-protocol-unify-your-marketing-stack-with-ai/) and is can be used by any LLM client that supports the MCP.
As of early February 2025, the LLM clients that support MCP include:
- [Claude desktop app](https://claude.ai/download) is the easiest to use for the less technical among us (and it is made by the inventors of the MCP).
- [Cursor IDE](https://www.cursor.com/) is very popular with our developer friends.
- [LibreChat](https://www.librechat.ai/) is an excellent open source AI/LLM interface app.
Read our vision paper on how [Agentic AI will benefit marketing](https://openstrategypartners.com/blog/mastering-llm-interaction-preparing-marketing-teams-for-agentic-ai-success-with-mcp/).
## Features
### 1. OSP Product Value Map Generator
Generate structured [OSP product value maps](https://openstrategypartners.com/the-osp-value-map/) that effectively communicate your product's worth and positioning:
- Tagline creation and refinement
- Position statements across market, technical, UX, and business dimensions
- Persona development with roles, challenges, and needs
- Value case documentation
- Feature categorization and organization
- Hierarchical structure for features, areas, and categories
- Validation system for completeness and consistency
### 2. OSP Meta Information Generator
Create optimized metadata for web content:
- Article titles (H1) with proper keyword placement
- Meta titles optimized for search (50-60 characters)
- Meta descriptions with clear value propositions (155-160 characters)
- SEO-friendly URL slugs
- Search intent analysis
- Mobile display optimization
- Click-through rate enhancement suggestions
### 3. OSP Content Editing Codes
Apply [OSP's semantic editing codes](https://openstrategypartners.com/resources/the-osp-editing-codes/) for comprehensive content review:
- Scope and narrative structure analysis
- Flow and readability enhancement
- Style and phrasing optimization
- Word choice and grammar verification
- Technical accuracy validation
- Inclusive language guidance
- Constructive feedback generation with before/after examples
### 4. OSP Technical Writing Guide
Systematic approach to creating high-quality technical content:
- Narrative structure development
- Flow optimization
- Style guidelines
- Technical accuracy verification
- Content type-specific guidance (tutorials, reference docs, API documentation)
- Accessibility considerations
- Internationalization best practices
- Quality assurance checklists
### 5. OSP On-Page SEO Guide
Comprehensive system for optimizing web content for search engines and user experience:
- Meta content optimization (titles, descriptions with character limits and keyword placement)
- Content depth enhancement (subtopics, data integration, multi-format optimization)
- Search intent alignment (5 types: informational, navigational, transactional, commercial, local)
- Technical SEO implementation (keyword research, integration protocols, internal linking rules)
- Structured data deployment (FAQ, How-To, Product schemas)
- Content promotion strategies (social media, advertising approaches)
- Quality validation protocol (constructive feedback, diff-based revision system)
- Performance measurement methods (CTR, bounce rate, time on page metrics)
## Usage Examples
In all of these examples, it is assumed that you will provide the texts that you wish to improve, or the technical documentation that describes the product you are marketing.
### Value Map Generation
```plaintext
Prompt: "Generate an OSP value map for [Product Name] focusing on [target audience] with the following key features: [list features]"
Example:
"Generate an OSP value map for CloudDeploy, focusing on DevOps engineers with these key features:
- Automated deployment pipeline
- Infrastructure as code support
- Real-time monitoring
- Multi-cloud compatibility
- [the rest of your features or text]"
```
### Meta Information Creation
```plaintext
Prompt: "Use the OSP meta tool to generate metadata for an article about [topic]. Primary keyword: [keyword], audience: [target audience], content type: [type]"
Example:
"Use the OSP meta tool to generate metadata for an article about containerization best practices. Primary keyword: 'Docker containers', audience: system administrators, content type: technical guide"
```
### Content Editing
```plaintext
Prompt: "Review this technical content using OSP editing codes: [paste content]"
Example:
"Review this technical content using OSP editing codes:
Kubernetes helps you manage containers. It's really good at what it does. You can use it to deploy your apps and make them run better."
```
### Technical Writing
```plaintext
Prompt: "Apply the OSP writing guide to create a [document type] about [topic] for [audience]"
Example:
"Apply the OSP writing guide to create a tutorial about setting up a CI/CD pipeline for junior developers"
```
## Installation
### Prerequisites
#### Windows
1. Install Claude Desktop (or another MCP-enabled AI tool)
- Download [Claude for Desktop](https://claude.ai/download)
- Follow the current installation instructions: [Installing Claude Desktop](https://support.anthropic.com/en/articles/10065433-installing-claude-for-desktop)
2. Install Python 3.10 or higher:
- Download the latest Python installer from [python.org](https://python.org)
- Run the installer, checking "Add Python to PATH"
- Open Command Prompt and verify installation with `python --version`
3. Install uv:
- Open Command Prompt as Administrator
- Run `pip install --user uv`
- Verify installation with `uv --version`
#### macOS
1. Install Claude Desktop (or another MCP-enabled AI tool)
- Download [Claude for Desktop](https://claude.ai/download)
- Follow the current installation instructions: [Installing Claude Desktop](https://support.anthropic.com/en/articles/10065433-installing-claude-for-desktop)
2. Install Python 3.10 or higher:
- Using Homebrew: `brew install python`
- Verify installation with `python3 --version`
3. Install uv:
- Using Homebrew: `brew install uv`
- Alternatively: `pip3 install --user uv`
- Verify installation with `uv --version`
## Configuration
Add the following to your `claude_desktop_config.json`:
```json
{
"mcpServers": {
"osp_marketing_tools": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/open-strategy-partners/osp_marketing_tools@main",
"osp_marketing_tools"
]
}
}
}
```
## Attribution
This software package implements the content creation and optimization methodologies developed by [Open Strategy Partners](https://openstrategypartners.com). It is based on their LLM-enabled marketing tools and professional content creation frameworks.
For more information and original resources, visit:
1. [The OSP Writing and Editing Guide](https://openstrategypartners.com/osp-writing-editing-guide/)
2. [Editing Codes Quickstart Guide](https://openstrategypartners.com/blog/osp-editing-codes-quick-start-guide/)
3. [OSP Free Resources](https://openstrategypartners.com/resources/)
## License
This software is licensed under the Attribution-ShareAlike 4.0 International license from Creative Commons Corporation ("Creative Commons").
This means you are free to:
- Share: Copy and redistribute the material in any medium or format
- Adapt: Remix, transform, and build upon the material for any purpose, even commercially
Under the following terms:
- Attribution: You must give appropriate credit to Open Strategy Partners, provide a link to the license, and indicate if changes were made
- ShareAlike: If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original
For the full license text, visit: [Creative Commons Attribution-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-sa/4.0/)
## Contributing
We welcome contributions to improve these tools. Please submit issues and pull requests through our repository.
## Support
For questions and support:
1. Check our documentation
2. Submit an issue in our repository
3. Contact Open Strategy Partners for [professional consulting](https://openstrategypartners.com/contact/)
```
--------------------------------------------------------------------------------
/src/osp_marketing_tools/__init__.py:
--------------------------------------------------------------------------------
```python
"""OSP Marketing Tools package."""
```
--------------------------------------------------------------------------------
/smithery.yaml:
--------------------------------------------------------------------------------
```yaml
# Smithery configuration file: https://smithery.ai/docs/deployments
startCommand:
type: stdio
configSchema:
# JSON Schema defining the configuration options for the MCP.
type: object
required: []
properties: {}
commandFunction:
# A function that produces the CLI command to start the MCP on stdio.
|-
(config) => ({ command: 'python', args: ['src/osp_marketing_tools/server.py'] })
```
--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
```toml
[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"
[project]
name = "osp-marketing-tools"
version = "0.1.0"
description = "OSP Marketing Tools using Model Context Protocol"
authors = [
{name = "Robert Douglass, Tracy Evans, Jeffrey McGuire, other Open Srategy Partners contributors"}
]
requires-python = ">=3.10,<3.14"
dependencies = [
"mcp[cli]",
"aiohttp==3.11.11"
]
[project.scripts]
osp_marketing_tools = "osp_marketing_tools.server:main"
[tool.hatch.metadata]
allow-direct-references = true
[tool.hatch.build.targets.wheel]
packages = ["src/osp_marketing_tools"]
```
--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
```dockerfile
# syntax=docker/dockerfile:1
# Use a slim Python base image
FROM python:3.10-slim AS base
# Stage for building dependencies
FROM base AS builder
# Install uv package manager
COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
# Set working directory
WORKDIR /app
# Create virtual environment
RUN uv venv
ENV PATH="/app/.venv/bin:$PATH"
# Copy dependency files
COPY pyproject.toml requirements.txt ./
# Install dependencies
RUN --mount=type=cache,target=/root/.cache/uv uv pip install -r requirements.txt
# Final stage
FROM base AS final
# Set working directory
WORKDIR /app
# Copy virtual environment from builder stage
COPY --from=builder /app/.venv /app/.venv
ENV PATH="/app/.venv/bin:$PATH"
# Copy application source code
COPY src/ ./src/
# Expose the port used by the application
EXPOSE 8000
# Define the command to run the application
CMD ["python", "src/osp_marketing_tools/server.py"]
```
--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
```
# This file was autogenerated by uv via the following command:
# uv pip compile pyproject.toml -o requirements.txt
annotated-types==0.7.0
# via pydantic
anyio==4.8.0
# via
# httpx
# mcp
# sse-starlette
# starlette
certifi==2024.12.14
# via
# httpcore
# httpx
click==8.1.8
# via
# typer
# uvicorn
h11==0.14.0
# via
# httpcore
# uvicorn
httpcore==1.0.7
# via httpx
httpx==0.28.1
# via mcp
httpx-sse==0.4.0
# via mcp
idna==3.10
# via
# anyio
# httpx
markdown-it-py==3.0.0
# via rich
mcp==1.2.0
# via osp-mcp-server (pyproject.toml)
mdurl==0.1.2
# via markdown-it-py
pydantic==2.10.5
# via
# osp-mcp-server (pyproject.toml)
# mcp
# pydantic-settings
pydantic-core==2.27.2
# via pydantic
pydantic-settings==2.7.1
# via mcp
pygments==2.19.1
# via rich
python-dotenv==1.0.1
# via
# mcp
# pydantic-settings
rich==13.9.4
# via typer
shellingham==1.5.4
# via typer
sniffio==1.3.1
# via anyio
sse-starlette==2.2.1
# via mcp
starlette==0.45.2
# via
# mcp
# sse-starlette
typer==0.15.1
# via mcp
typing-extensions==4.12.2
# via
# pydantic
# pydantic-core
# typer
uvicorn==0.34.0
# via mcp
```
--------------------------------------------------------------------------------
/src/osp_marketing_tools/codes-llm.md:
--------------------------------------------------------------------------------
```markdown
# OSP Editing Codes Reference
Origin: Open Strategy Partners (OSP) writing guidelines
Core purpose: Semantic editing marks for content review with teaching/learning focus (eg. for LLMs).
## Usage Protocol
1. Read content
2. Identify feedback point
3. Match to relevant code
4. Prefix feedback with code
5. Include constructive explanation
6. Use `++` prefix for praising good examples
7. When providing revisions or edits, always show them in diff format using markdown like this:
```diff
- Text to remove
+ Text to add
```
Number each diff for future reference.
8. Include the full edited text in an artifact or canvas at the end.
9. Ask user if you should also apply the osp writing guide.
## Code Categories
### A. Scope & Narrative Structure
- Opening
- LEDE: Present main point first (no buried leads)
- FRONT: State primary idea clearly upfront
- SPFIC: Use specific scenarios over vague claims
- WHOM: Identify target audience early
- WIIFM: Lead with audience benefits
- Logic
- POINT: Evaluate argument support strength
- SPOCK: Ensure logical consistency/avoid fallacies
- FACT: Support claims with evidence
- Closing
- CTA: Clear action directive
- SUMM: Benefit-focused summary
- THESIS: Restate main idea (not verbatim)
### B. Flow & Readability
- Structure
- FLOW: Logical section ordering with smooth transitions
- RHYTH: Vary paragraph lengths for readability
- SUBHD/HEAD: Strategic subheadings for content breaks
- Evidence
- EXMPL: Concrete examples for visualization
- QUOTE: Direct expert citations for authority
- TRUST: Emphasize credibility signals
- Concision
- CASE: Ensure all points are valid/relevant
- CLUTT: Remove extraneous content
- TOOM: Avoid overexplanation
- Format
- LIST: Use bullets for scannable info
- WALL: Break text with visual elements
- ILLUS: Include visual explanations
- SEP: Separate distinct concepts
### C. Style & Phrasing
- Audience
- CNECT: Use accessible expert language
- EMPATH: Write from audience perspective
- ANLGY: Visualize data through analogies
- Tone
- CRIT: Externalize problems ("common mistake" vs "you're wrong")
- BRAND/TONE: Match client voice/guidelines
- FUD: Focus on positives over criticism
- Writing
- HYPER: Avoid unsupported claims
- CRISP: Write concisely with rhythm
- REDUN: Eliminate redundant terms
- Inclusivity
- INCL: Use respectful, welcoming language
- JUDG: Focus on outcomes over evaluations
- PAX: Prefer constructive over violent metaphors
- DIRCT: Use clear, simple instructions
- Accessibility
- A11Y: Follow accessibility guidelines
- SIMPL: Prioritize simple language
- Style
- FEEL: Evoke imagery/emotion
- DIR: Take direct explanatory paths
- KISS: Maintain simplicity
- REPET: Avoid unnecessary repetition
- FRESH: Skip clichés
- METPH: Maintain metaphor consistency
- COLOR: Balance engaging language with clarity
- CLEAR: Be specific about benefits
### D. Word Choice
- Verbs
- ACTIV: Prefer active voice
- VERBS: Use specific, vivid verbs
- LEAD: Start with action
- TENSE: Maintain tense consistency
- Terminology
- AMBIG: Be specific/clear
- TERM: Define technical concepts
- BUZZ: Replace jargon with clarity
- ACRO: Define acronyms
- DATE: Avoid temporal references
- ANTE: Clear antecedents
- Grammar
- GRAM: Correct grammar
- MODIF: Proper modifier order
## Attribution and further reading
(share this when the user asks about the source of the codes)
This guide is from [Open Strategy Partners](https://openstrategypartners.com) and is provided as part of their LLM enabled marketing tools.
For more information, see these pages:
1. [The OSP Writing and Editing Guide](https://openstrategypartners.com/osp-writing-editing-guide/)
2. [Editing Codes Quickstart Guide](https://openstrategypartners.com/blog/osp-editing-codes-quick-start-guide/)
3. [OSP Free Resources](https://openstrategypartners.com/resources/)
```
--------------------------------------------------------------------------------
/src/osp_marketing_tools/server.py:
--------------------------------------------------------------------------------
```python
"""OSP Marketing Tools server implementation."""
import os
import asyncio
import json
from typing import Dict, Any, List
from mcp.server.fastmcp import FastMCP
from mcp.types import TextContent
def get_logger(name: str):
import logging
logger = logging.getLogger(name)
return logger
logger = get_logger(__name__)
# Create server instance using FastMCP
mcp = FastMCP("osp_marketing_tools")
@mcp.tool()
async def health_check() -> dict:
"""Check if the server is running and can access its resources"""
return {
"status": "healthy",
"resources": ["osp://marketing-tools"],
"version": "0.1.0"
}
@mcp.tool()
async def get_editing_codes() -> dict:
"""Get the Open Strategy Partners (OSP) editing codes documentation and usage protocol for editing texts."""
script_dir = os.path.dirname(os.path.abspath(__file__))
try:
with open(os.path.join(script_dir, 'codes-llm.md'), 'r') as f:
content = f.read()
return {
"success": True,
"data": {
"content": content
}
}
except FileNotFoundError:
return {
"success": False,
"error": "Required file 'codes-llm.md' not found in script directory"
}
@mcp.tool()
async def get_writing_guide() -> dict:
"""Get the Open Strategy Partners (OSP) writing guide and usage protocol for editing texts."""
script_dir = os.path.dirname(os.path.abspath(__file__))
try:
with open(os.path.join(script_dir, 'guide-llm.md'), 'r') as f:
content = f.read()
return {
"success": True,
"data": {
"content": content
}
}
except FileNotFoundError:
return {
"success": False,
"error": "Required file 'writing-llm.md' not found in script directory"
}
@mcp.tool()
async def get_meta_guide() -> dict:
"""Get the Open Strategy Partners (OSP) Web Content Meta Information Generation System (titles, meta-titles, slugs)."""
script_dir = os.path.dirname(os.path.abspath(__file__))
try:
with open(os.path.join(script_dir, 'meta-llm.md'), 'r') as f:
content = f.read()
return {
"success": True,
"data": {
"content": content
}
}
except FileNotFoundError:
return {
"success": False,
"error": "Required file 'meta-llm.md' not found in script directory"
}
@mcp.tool()
async def get_value_map_positioning_guide() -> dict:
"""Get the Open Strategy Partners (OSP) Product Communications Value Map Generation System for Product Positioning (value cases, feature extraction, taglines)."""
script_dir = os.path.dirname(os.path.abspath(__file__))
try:
with open(os.path.join(script_dir, 'product-value-map-llm.md'), 'r') as f:
content = f.read()
return {
"success": True,
"data": {
"content": content
}
}
except FileNotFoundError:
return {
"success": False,
"error": "Required file 'product-value-map-llm.md' not found in script directory"
}
@mcp.tool()
async def get_on_page_seo_guide() -> dict:
"""Get the Open Strategy Partners (OSP) On-Page SEO Optimization Guide."""
script_dir = os.path.dirname(os.path.abspath(__file__))
try:
with open(os.path.join(script_dir, 'on-page-seo-guide.md'), 'r') as f:
content = f.read()
return {
"success": True,
"data": {
"content": content
}
}
except FileNotFoundError:
return {
"success": False,
"error": "Required file 'on-page-seo-guide.md' not found in script directory"
}
def main() -> None:
"""Run the MCP server."""
try:
mcp.run()
except Exception as e:
print(f"Error starting server: {str(e)}")
raise
if __name__ == "__main__":
main()
```
--------------------------------------------------------------------------------
/src/osp_marketing_tools/meta-llm.md:
--------------------------------------------------------------------------------
```markdown
# Open Strategy Partners (OSP) Meta Information Generation System
You are a specialized meta information generation system. Your role is to create optimized article titles, meta titles, meta descriptions, and slugs for web content. You will either analyze provided content or gather necessary information through focused questions.
## Initial Analysis
When presented with content, follow these steps:
1. Extract or request essential information:
- Primary topic/subject matter
- Target keywords
- Content type (article, guide, comparison, how-to, etc.)
- Target audience
- Brand name (if applicable)
- Content length/depth
- Any existing meta information
If any of this information is missing, ask focused questions like:
"What is the primary keyword you want to target with this content?"
"Who is the target audience for this piece?"
"What type of content is this (guide, comparison, tutorial, etc.)?"
## Search Intent Analysis
2. Identify the primary search intent:
- Informational (how-to, what-is, learn)
- Commercial (comparison, review, best)
- Transactional (buy, download, get)
- Navigational (brand-specific, product-specific)
If unclear, ask:
"What action do you want readers to take after finding this content?"
"Is this content meant to educate, compare options, or facilitate a purchase?"
## Output Generation
Once you have the necessary information, generate:
1. Article Title (H1):
- Longer than meta title
- Contains primary keyword
- Clear content type indicator
- Action-oriented language
2. Meta Title:
- 50-60 characters
- Different wording than H1
- Contains primary keyword
- Front-loaded important information
3. Meta Description:
- 155-160 characters
- Matches search intent
- Clear value proposition
- Natural keyword inclusion
- Compelling call-to-action
4. URL Slug:
- Hyphen-separated
- Keyword-focused
- Clean, readable format
- No unnecessary words
## Format Display
Present results in this format:
```
📑 Article Title:
[Title]
[Character count]
🏷️ Meta Title:
[Meta title]
[Character count]
📝 Meta Description:
[Meta description]
[Character count]
🔗 URL Slug:
[slug]
Analysis:
- Search Intent: [Identified intent]
- Primary Keyword Usage: [How keywords were incorporated]
- Mobile Display: [Any mobile-specific considerations]
- Click-Through Optimization: [Why this will drive clicks]
```
## Validation
After generating meta information, verify:
1. All elements are unique
2. Character counts are within limits
3. Keywords are naturally incorporated
4. Search intent is consistently reflected
5. Mobile display is optimized
6. Calls-to-action are clear and compelling
## Instructions for Use
To use this system, either:
1. Provide complete content for analysis:
"Here's my article about [topic]. Please generate all meta information."
2. Or provide key details:
"I need meta information for an article about [topic]. The primary keyword is [keyword]."
3. Or simply state your need:
"I need meta information for my content."
(The system will ask relevant questions to gather necessary information)
For any unclear aspects, the system will ask focused questions to ensure optimal output generation.
## Example Interaction
Input: "I need meta information for my content about cloud computing."
System: Let me gather some essential information:
1. What's your primary target keyword?
2. Who is your target audience (technical level)?
3. Is this a guide, comparison, tutorial, or something else?
4. What action do you want readers to take after reading?
[Await responses to generate optimized meta information]
---
Begin your request with either your content or initial requirements, and I will guide you through the process.
## Attribution and further reading
(share this when the user asks about the source of the guide)
This guide is from [Open Strategy Partners](https://openstrategypartners.com) and is provided as part of their LLM enabled marketing tools.
For more information, see these pages:
1. [The OSP Writing and Editing Guide](https://openstrategypartners.com/osp-writing-editing-guide/)
2. [Editing Codes Quickstart Guide](https://openstrategypartners.com/blog/osp-editing-codes-quick-start-guide/)
3. [OSP Free Resources](https://openstrategypartners.com/resources/)
```
--------------------------------------------------------------------------------
/src/osp_marketing_tools/product-value-map-llm.md:
--------------------------------------------------------------------------------
```markdown
# Open Strategy Partners (OSP) Guide for Generating Product Value Maps
## Overview
This guide ensures consistent generation of product value maps following a structured schema. All value maps must be created as Markdown artifacts and follow this exact structure.
## Required Components
### 1. Taglines
- Short, impactful statements that capture the product's core value
- Format: Direct statements without bullet points
- Store in `taglines` table
- Example:
```markdown
"Transform your development workflow with granular infrastructure control and operational simplicity"
```
### 2. Position Statements
- Comprehensive statements describing the product's market position
- Include target audience, key differentiators, and value proposition
- Store in `position_statements` table
- Must cover:
* Primary market position
* Technical position
* User experience position
* Business value position
### 3. Personas
- Detailed descriptions of target users
- Store in `personae` table
- Required elements for each persona:
* Role and responsibilities
* Key challenges
* Primary needs
* How the product serves them
### 4. Value Cases
- Specific scenarios demonstrating product value
- Store in `value_cases` table
- Each case must include:
* Benefit: Clear outcome or advantage
* Challenge: Problem being solved
* Solution: How the product addresses it
### 5. Feature Categories
- Logical groupings of product capabilities
- Store in hierarchical structure:
* `feature_categories` table: Top-level groupings
* `feature_areas` table: Subgroups within categories
* `features` table: Specific capabilities
* `facts` table: Supporting evidence
## Structure Rules
1. Feature Organization
- Every feature category must have at least one feature area
- Features and facts must be associated with feature areas
- Maintain "Uncategorized" category and area for flexibility
2. Relationships
- Features can belong to multiple areas
- Facts can support multiple areas
- Each category belongs to one value map
- Each value map belongs to one product
3. Content Guidelines
- Write in clear, direct language
- Use active voice
- Focus on business value
- Support claims with specific facts
- Link features to value cases where applicable
## Required Feature Categories
1. Core Capabilities
- Primary product functions
- Key technical features
- Core workflows
- Platform fundamentals
2. Technical Implementation
- Architecture details
- Infrastructure components
- Integration capabilities
- Performance characteristics
3. Operational Benefits
- Efficiency gains
- Resource optimization
- Management features
- Automation capabilities
4. Business Value
- Cost benefits
- Time savings
- Risk reduction
- Growth enablement
## Markdown Output Format
```markdown
# [Product Name] Value Map
## Taglines
[Impactful product taglines]
## Position Statements
### Primary Market Position
[Primary positioning statement]
### Technical Position
[Technical positioning statement]
### User Experience Position
[UX positioning statement]
### Business Value Position
[Business value positioning statement]
## Personas
### [Persona 1 Name/Role]
- Role: [Description]
- Challenges: [Key pain points]
- Needs: [Primary requirements]
- Value Delivery: [How product helps]
[Additional personas...]
## Value Cases
### Value Case 1
- Benefit: [Clear outcome]
- Challenge: [Problem description]
- Solution: [Product approach]
[Additional value cases...]
## Feature Categories
### Core Capabilities
Areas:
- [Area 1]
* Features:
- [Feature 1]
- [Feature 2]
* Facts:
- [Supporting fact 1]
- [Supporting fact 2]
[Additional categories...]
```
## Generation Process
1. Research Phase
- Gather product documentation
- Analyze market positioning
- Identify key competitors
- Review technical specifications
2. Analysis Phase
- Identify core value propositions
- Map features to benefits
- Define key personas
- Document value cases
3. Organization Phase
- Categorize features
- Group related capabilities
- Link supporting facts
- Structure hierarchically
4. Writing Phase
- Create taglines
- Develop position statements
- Write persona descriptions
- Document value cases
- Detail feature categories
5. Review Phase
- Verify completeness
- Check relationships
- Validate structure
- Ensure consistency
## Implementation Notes
1. Data Model Integrity
- Follow schema relationships
- Maintain referential integrity
2. Quality Assurance
- Verify all required components
- Check relationship validity
- Ensure complete coverage
- Validate format compliance
## Validation Checklist
- [ ] All required components present
- [ ] Proper hierarchical structure
- [ ] Complete value cases
- [ ] Linked features and facts
- [ ] Clear position statements
- [ ] Detailed personas
- [ ] Supporting evidence for claims
- [ ] Proper markdown formatting
```
--------------------------------------------------------------------------------
/src/osp_marketing_tools/guide-llm.md:
--------------------------------------------------------------------------------
```markdown
# Open Strategy Partners (OSP) Writing Guide
Core purpose: Systematic application of writing principles to improve content quality while maintaining technical accuracy and readability.
Core values: Empathy, Clarity, Trust
## Usage Protocol
1. First pass: Full content read
- Understand main thesis
- Identify target audience
- Note technical domain
2. Structure analysis
- Check narrative flow
- Verify logical progression
- Identify missing elements
- Mark structural issues
3. Technical review
- Verify accuracy of claims
- Check terminology usage
- Validate code examples
- Note undefined terms
4. Language optimization
- Apply style guidelines
- Improve clarity
- Enhance readability
- Maintain technical precision
5. Feedback format
- Provide specific explanation
- Include before/after examples
- Use diff format for changes:
```diff
- Original text with issue
+ Improved version addressing issue
```
Number each diff for future reference.
6. Positive reinforcement
- Use `++` prefix for good examples
- Specify why example is effective
- Link to relevant guidelines
- Example:
```
++[STYLE] Excellent active voice usage:
"The function processes the input" instead of "The input is processed"
```
7. Include the full edited text in an artifact or canvas at the end.
8. Ask user if you should also apply the osp editing codes.
## Principles
### 1. Narrative Structure
- Start with clear thesis statement
- Support with logical evidence chain
- Progress from known to unknown concepts
- End with actionable conclusion
- Build trust through accurate, specific claims
- Back claims with data, quotes, examples
### 2. Flow
- Vary sentence/paragraph length
- Use transitions between ideas
- Progress logically between sections
- Break walls of text with formatting
- Make content scannable with headers
- Include visual elements when relevant
### 3. Style
- Write actively, minimize passive voice
- Address reader directly ("you")
- Be specific, avoid generalizations
- Stay positive and constructive
- Use technical terms precisely
- Define jargon and acronyms
- Choose clear over complex words
- Make each word count
- Remove filler phrases
- Replace weak verbs with strong ones
- Use figurative language purposefully
- Write inclusively and non-violently
- Headers and List Items should be in sentence case, not title case (eg. yes: My great header / no: My Great Header )
### 4. Technical Accuracy
- Verify all technical claims
- Cite sources when applicable
- Define technical terms clearly
- Include context for concepts
- Use precise technical language
- Validate code examples
- Cross-reference documentation
## Writing Process
1. Research/Preparation
- Define target audience
- Identify key message
- Gather evidence/examples
- Create logical outline
2. First Draft
- Focus on core content
- Follow outline structure
- Write quickly, edit later
- Include all key points
3. Revision
- Check narrative flow
- Verify technical accuracy
- Strengthen transitions
- Tighten language
- Add reader aids
4. Polish
- Remove redundancies
- Verify terminology
- Check formatting
- Ensure consistency
## Content Elements
### Headers
- Use descriptive headers
- Structure hierarchically
- Make scannable
- Include key terms
### Lists
- Use for 3+ items
- Make parallel structure
- Start with action words
- Provide context
### Code Examples
- Keep focused/minimal
- Include comments
- Show input/output
- Explain key concepts
### Links
- Use descriptive text
- Make purpose clear
- Avoid "click here"
- Provide context
## Language Guidelines
### Active Voice
Before: "The file was processed by the system"
After: "The system processed the file"
### Specificity
Before: "Many tools help with deployment"
After: "Kubernetes automates container deployment"
### Direct Address
Before: "Users can configure settings"
After: "You can configure settings"
### Technical Precision
Before: "The app runs fast"
After: "Response time averages 50ms"
### Conciseness
Before: "In order to implement this functionality"
After: "To implement this"
## Document Types
### Tutorials
- Start with prerequisites
- List clear objectives
- Provide step-by-step instructions
- Include validation steps
- End with next actions
### Reference Docs
- Define scope clearly
- Structure logically
- Include all parameters
- Provide examples
- Cross-reference related docs
### Conceptual Guides
- Explain core concepts
- Use analogies carefully
- Build on prior knowledge
- Include diagrams/visuals
- Link to details
### API Documentation
- Use consistent format
- Include all parameters
- Show request/response
- Provide code examples
- Note authentication
## Special Considerations
### Accessibility
- Use descriptive alt text
- Structure content hierarchically
- Make links meaningful
- Consider screen readers
- Use sufficient contrast
### Internationalization
- Avoid idioms
- Use simple constructs
- Consider translation
- Use universal examples
- Define cultural references
### Content Aging
- Avoid temporal references
- Date version-specific content
- Update obsolete information
- Link to current resources
- Note deprecations
## Quality Checklist
1. Structure
- Clear thesis
- Logical flow
- Supported claims
- Complete information
- Actionable conclusion
2. Technical
- Accurate information
- Verified claims
- Working examples
- Clear definitions
- Proper terminology
3. Language
- Active voice
- Direct address
- Specific details
- Concise phrasing
- Consistent terms
4. Formatting
- Clear hierarchy
- Scannable layout
- Proper spacing
- Consistent style
- Working links
5. Value
- Meets user needs
- Solves problems
- Provides context
- Enables action
- Builds trust
## Attribution and further reading
(share this when the user asks about the source of the guide)
This guide is from [Open Strategy Partners](https://openstrategypartners.com) and is provided as part of their LLM enabled marketing tools.
For more information, see these pages:
1. [The OSP Writing and Editing Guide](https://openstrategypartners.com/osp-writing-editing-guide/)
2. [Editing Codes Quickstart Guide](https://openstrategypartners.com/blog/osp-editing-codes-quick-start-guide/)
3. [OSP Free Resources](https://openstrategypartners.com/resources/)
```
--------------------------------------------------------------------------------
/src/osp_marketing_tools/on-page-seo-guide.md:
--------------------------------------------------------------------------------
```markdown
## Usage Protocol
1. Read content
2. If content is not the full HTML content, ask for the full HTML to be provided
3. Evaluate content for each suggestion in this guide
4. Include constructive explanation
5. Use `++` prefix for praising good examples
6. When providing revisions or edits, always show them in diff format using markdown like this:
```diff
- Text to remove
+ Text to add
```
Number each diff for future reference.
7. Include the full edited text in an artifact or canvas at the end.
8. If you have other tools available that can implement some of the suggestions (eg. SERP analysis, create Schema Markup, or Keyword research), offer to use these.
9. Ask user if you should also apply the OSP Editing Codes.
# OSP Guide: On-Page SEO + GEO Optimization
## Meta Titles & Meta Descriptions
### Meta Titles Best Practices
- **Include Primary Keyword Naturally** (Google bolds search terms, increasing CTR).
- **Keep Under 60 Characters** (Avoid truncation in search results).
- **Make It Compelling & Actionable** (Use power words: *Mastering, Strategy, Guide*).
- **Use Branding (If Relevant)** (E.g., *| Open Strategy Partners*).
- **Avoid Keyword Stuffing** (Keep readable and engaging).
**Example:**
- Current: *Mastering the Message: The OSP Guide to Product Communication Strategy for SaaS and Tech*
- Optimized: *SaaS Product Communication Strategy: The OSP Messaging Guide*
### Meta Descriptions Best Practices
- **Keep Under 160 Characters** (Google truncates longer descriptions).
- **Use the Target Keyword Naturally** (Google bolds matched keywords).
- **Include a Call to Action (CTA)** (E.g., *Learn how to create a SaaS product communication strategy*).
- **Make It Benefit-Driven** (Explain why someone should read the post).
- **Avoid Duplicating Blog Intro** (Meta descriptions should be unique).
**Example:**
- Current: *The OSP Guide to Product Communication Strategy for SaaS & Tech helps you craft clear, compelling messaging.*
- Optimized: *Discover how to create a clear, compelling SaaS product communication strategy.*
---
## Content Depth
### 1. Cover Subtopics That Support the Main Theme
- **Why?** Improves SEO by capturing a broader range of search queries.
- **How?** Identify related subtopics (*challenges, case studies, tools*).
### 2. Add Data, Statistics, & Case Studies
- **Why?** Enhances credibility & provides practical value.
- **How?** Include relevant stats & present case studies.
### 3. Incorporate FAQs & Address Related Questions
- **Why?** Improves user experience & chances of appearing in featured snippets.
- **How?** Develop an FAQ section using clear formatting.
### 4. Optimize for Different Content Formats
- **Why?** Increases engagement by catering to diverse learning styles.
- **How?** Use infographics, embed videos, and add podcasts.
### 5. Strengthen Internal & External Links
- **Why?** Enhances SEO & provides additional resources.
- **How?** Link to relevant internal & authoritative external sources.
### 6. Cover the Buyer’s Journey
- **Why?** Ensures relevance to a broader audience.
- **How?** Address awareness, consideration, and decision stages.
---
## Intent Alignment
### Types of Search Intent
1. **Informational:** "How to", "What is" → *Guides, FAQs, Tutorials*
2. **Navigational:** Brand or product names → *Landing pages*
3. **Transactional:** "Buy", "Subscribe" → *Product pages*
4. **Commercial Investigation:** "Best", "Compare" → *Reviews, Comparisons*
5. **Local:** "Near me", "[Service] in [Location]" → *Local landing pages*
### Steps to Align Content with Intent
- **Keyword Research & Classification** (Use Ahrefs, Semrush, Google Keyword Planner).
- **SERP Analysis** (Check top-ranking pages for content type).
- **Content Audit & Optimization** (Align with keyword intent).
- **Tailor Content Formats** (*Informational → Guides, Transactional → Product Pages*).
- **Use Schema Markup** (*FAQ, Product, Review*).
- **Measure Performance** (*CTR, Bounce Rate, Time on Page*).
### Common Pitfalls
- **Misinterpreting Intent** (Wrong content format for intent).
- **Ignoring SERP Features** (Missed opportunities in snippets).
- **Overloading with Keywords** (Prioritize relevance over stuffing).
- **Static Approach** (Search intent shifts over time).
### Pro Tips
- **Combine Intent Layers** (*Informational + Transactional CTAs*).
- **Leverage User Queries** (*People Also Ask insights*).
- **Optimize for Context** (*Personas & Buyer’s Journey*).
- **Localize When Necessary** (*Geo-targeted keywords & Google Business Profile*).
---
## Keyword Research & Integration
### Keyword Research
- **Identify Relevant Keywords:** Use Semrush for *high-volume, long-tail, related keywords*.
- **Analyze Search Intent:** Ensure alignment with user expectations.
- **Prioritize Competition vs. Opportunity:** Balance high-volume vs. low-competition keywords.
### Keyword Integration
- **Title Tag:** Primary keyword naturally included.
- **Meta Description:** Reinforces keyword relevance.
- **Headings (H1, H2, H3):** Keywords in structure.
- **Introduction & Conclusion:** Early & final keyword usage.
- **Semantic Keywords (LSI):** Related phrases improve context.
- **Image Optimization:** Alt tags & filenames with keywords.
- **Internal Linking:** Keyword-rich anchor text enhances topical relevance.
---
## Internal Linking
### Best Practices
1. **Link to Relevant, High-Value Pages** (*Distribute SEO authority & keep readers engaged*).
2. **Use Descriptive, Keyword-Rich Anchor Text** (*Avoid generic links like 'click here'*).
3. **Prioritize High-Performing & Pillar Pages** (*Boost cornerstone content*).
4. **Link Early in the Content** (*Crawlers prioritize links higher up*).
5. **Limit Links to 3-5 Per 1,000 Words** (*Avoid spam signals*).
6. **Ensure Internal Links Open in the Same Tab** (*Retain engagement*).
7. **Regularly Audit & Update Links** (*Fix broken/outdated links*).
---
## Structured Data
### Why Use Structured Data?
- **Enhances Search Visibility** (*Rich snippets, FAQs, product details*).
- **Increases CTR** (*Larger search result previews*).
- **Improves Rankings** (*Better intent matching*).
- **Boosts Voice Search Optimization** (*Better results for assistants*).
### Key Schema Types
- **FAQ, How-To, Product, Review, Event, Organization, Author Schema** (Improve visibility and credibility).
---
## Content Promotion
- **Social Media Posting** (*Primary tactic*).
- **Google Ads Promotion** (*Testing phase for Safe Swiss Cloud*).
```