Enables analysis of Jira tickets for implementation planning and guidance in Optimizely development.
Provides optional AI-powered embeddings and semantic search for enhanced documentation retrieval and context analysis in Optimizely development.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@optivise Analyze this code for Optimizely Commerce issues"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Optivise is an intelligent MCP (Model Context Protocol) tool that enhances AI-assisted Optimizely development. It analyzes developer prompts for Optimizely relevance and provides curated, contextual information to LLMs.
5 Specialized MCP Tools:
optidev_context_analyzer: Enhanced context analysis with product detection
optidev_implementation_guide: Jira ticket analysis and implementation planning
optidev_debug_helper: Intelligent bug analysis and resolution
optidev_code_analyzer: Real-time code analysis and optimization
optidev_project_helper: Project setup, migration, and configuration assistance
AI-Powered Capabilities (Optional):
OpenAI integration for embeddings and semantic search (optional)
ChromaDB vector database for documentation search (optional)
Deterministic relevance scoring with evidence and rules
Graceful fallbacks when AI features unavailable
Observability & Safety:
Structured JSON logs on stderr with correlation IDs; MCP stdout clean
Log redaction, block sanitization (scripts/iframes/JS/data URIs), content size ceilings
Diagnostics with per-stage timings and relevance breakdown
Related MCP server: ctxray
# Install Optivise globally
npm install -g optivise
# Verify installation
optivise versionCreate or update .cursor/mcp.json in your project:
{
"mcpServers": {
"optivise": {
"command": "npx",
"args": ["optivise-mcp"]
}
}
}Add to your VS Code settings:
{
"mcp.servers": [
{
"name": "optivise",
"command": "npx",
"args": ["optivise-mcp"]
}
]
}@optidev_context_analyzer "How do I implement a custom handler chain in Optimizely Commerce?"To enable AI-powered features:
{
"mcpServers": {
"optivise": {
"command": "npx",
"args": ["optivise-mcp"],
"env": {
"OPENAI_API_KEY": "your-api-key-here"
}
}
}
}# Propose a consolidated .cursorrules from discovered rules (prints JSON with diff)
optivise-rules propose /path/to/project
# Write the proposed .cursorrules to the project root
optivise-rules propose /path/to/project --write
# Print version and service diagnostics (AI/Chroma/doc-sync availability)
optivise-diag
# Query local HTTP server health or readiness
optivise-health # defaults to http://localhost:3007/health
optivise-health --ready # queries http://localhost:3007/ready
optivise-health --url=http://host:port/readyLOG_LEVEL: error|warn|info|debug (default: info)
OPTIVISE_MODE: mcp|server (default: mcp)
MAX_BLOCK_CHARS: max characters per context block (default: 5000)
MAX_TOTAL_TOKENS: hard safety ceiling for context tokens (default: 4000)
OPENAI_API_KEY: optional, enables AI-powered features
CORS_ALLOW_ORIGINS: comma-separated allowed origins for HTTP server (default: *)
REQUEST_TIMEOUT_MS: per-request timeout for /analyze (default: 15000)
AUDIT_API_KEY: enables protected GET /audit endpoint when OPTIVISE_AUDIT=true
OPTIVISE_AUDIT: set to 'true' to enable in-memory audit trail (requires AUDIT_API_KEY for access)
Verify Node.js version: Ensure Node.js >= 18.0.0
Restart IDE after configuration changes
Check logs: Set LOG_LEVEL=debug for detailed logs
Verify configuration: Ensure optivise-mcp is correctly referenced
Test connection: npx @modelcontextprotocol/inspector npx optivise-mcp
Use forward slashes or double backslashes in JSON:
"args": ["optivise-mcp"]See render.yaml for a minimal configuration:
services:
- type: web
name: optivise
env: node
plan: free
buildCommand: npm install && npm run build
startCommand: npm start
envVars:
- key: NODE_ENV
value: production
- key: OPTIVISE_MODE
value: server
- key: OPTIDEV_DEBUG
value: false
- key: CORS_ALLOW_ORIGINS
value: https://yourdomain.com
healthCheckPath: /healthAfter deployment:
GET /health for liveness
GET /ready for feature matrix + circuit states (OpenAI/Chroma)
Use optivise-health locally to check http://localhost:3007/health
Enable: set OPTIVISE_AUDIT=true and set a strong AUDIT_API_KEY.
Fetch recent events:
curl -H "Authorization: Bearer $AUDIT_API_KEY" http://localhost:3007/audit | jqLog redaction (API keys/tokens/passwords), correlation IDs, MCP stdout kept clean
Output sanitization and size bounds in formatter; relevance-aware truncation
Opt-in in-memory audit trail for tool invocations (protected endpoint)
Circuit breakers and backoff for AI/Chroma integrations; CI npm audit + CycloneDX SBOM
Planned (not yet implemented): stronger PII detection, allow-listed HTML sanitization, signed releases, and comprehensive policy scans (e.g., OSV).
@optidev_implementation_guide "Implement customer loyalty points system"
@optidev_debug_helper "Cart total calculation incorrect after discount applied"
@optidev_code_analyzer "Review this handler for performance optimization"@optidev_project_helper "Setup new Commerce + CMS integrated project"
@optidev_context_analyzer "Best practices for integrating Commerce with CMS"---
config:
theme: neo-dark
---
flowchart TD
User[User/Developer] -->|Prompt| IDE[IDE/CLI Interface]
IDE -->|Request| MCP[MCP Server]
MCP -->|Initialize| CAE[Context Analysis Engine]
MCP -->|Initialize| Tools[Specialized Tools]
MCP -->|Initialize| AI[AI Services]
subgraph "Context Analysis Flow"
CAE -->|Analyze Prompt| PA[Prompt Analyzer]
PA -->|Relevance Score & Intent| CAE
CAE -->|Detect Products| PDS[Product Detection Service]
PDS -->|Product Context| CAE
CAE -->|Analyze Rules| RIS[Rule Intelligence Service]
RIS -->|Rule Analysis| CAE
CAE -->|Fetch Documentation| DS[Documentation Service]
DS -->|Basic Docs| DOC[Documentation Sources]
DS -->|Vector Search| CDB[ChromaDB Service]
CDB -->|AI-Enhanced Search| OAI[OpenAI Client]
OAI -->|Embeddings| CDB
DS -->|Documentation Content| CAE
end
subgraph "AI Services"
AKDS[API Key Detector] -->|Detect Keys| OAI
AKDS -->|Detect Keys| CDB
DSS[Documentation Sync Service] -->|Sync| CDB
end
subgraph "Specialized Tools"
Tools -->|Implementation Guide| IGT[Implementation Guide Tool]
Tools -->|Debug Helper| DHT[Debug Helper Tool]
Tools -->|Code Analyzer| CAT[Code Analyzer Tool]
Tools -->|Project Helper| PHT[Project Helper Tool]
IGT & DHT & CAT & PHT -->|Use| CAE
end
CAE -->|Curated Context| MCP
MCP -->|Response| IDE
IDE -->|Enhanced Response| UserIDE Agent Integration: How to assemble prompts and previews in Cursor/VS Code
Developer Guide: How to develop, run, test, and integrate Optivise locally
Architecture Diagrams: System architecture and data flows
Product Requirements: Complete product requirements and features
Software Requirements: Technical specifications and interfaces
Project Plan: Development roadmap and timeline
Vision and Scope: Project vision and objectives
Todo List: Implementation status and completed features
Claude Integration: Guidance for Claude AI when working with this codebase
Issues: GitHub Issues
Support: Enterprise Support
Real-time code analysis for performance, security, and best practices
| Name | Required | Description | Default |
|---|---|---|---|
| language | No | Programming language (typescript, csharp, html, etc.) | |
| codeSnippet | Yes | Code snippet to analyze | |
| analysisType | No | Type of analysis to perform |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavioral traits. It mentions 'real-time' but does not describe return values, whether the tool makes any changes, or any side effects. There is no mention of output format or error conditions, leaving the agent with limited understanding of what to expect.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the core purpose ('Real-time code analysis'). It contains no filler or redundant information, and the critical terms (performance, security, best practices) are immediately visible. This is appropriately sized for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and no annotations, so the description is the only source for understanding the tool's behavior. It explains what the tool analyzes but not what it returns, how the analysis is presented, or any limitations. For an agent to invoke and use the tool effectively, more detail about the response or usage context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema descriptions cover all three parameters with 100% coverage, so the baseline is 3. The description does not add additional parameter-level detail beyond mentioning performance, security, and best practices, which aligns with the analysisType enum. It does not compensate for any gaps because there are none.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as a code analyzer with a focus on performance, security, and best practices. It distinguishes it from siblings like 'context_analyzer' and 'debug_helper' by specifying the resource (code) and the analysis domains. However, it lacks an explicit action verb like 'analyzes' and could be more specific about accepting a code snippet.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as 'optidev_context_analyzer' or 'optidev_debug_helper'. It does not state any prerequisites, exclusions, or preferred scenarios. The agent is left to infer usage solely from the tool name and schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Enhanced context analysis with AI-powered relevance scoring and vector search
| Name | Required | Description | Default |
|---|---|---|---|
| prompt | Yes | User prompt to analyze for Optimizely context | |
| enableAI | No | Enable AI-powered features (requires API keys) | |
| ideRules | No | Optional IDE rules for context enhancement | |
| projectPath | No | Optional project path for IDE context |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure, but it only mentions AI-powered relevance scoring and vector search. It doesn't disclose safety (read-only vs. mutating), API key requirements, side effects, or what happens when enableAI is false.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and front-loaded as a noun phrase, but it's under-specified and doesn't state the action verb. It's concise but not structured in a way that clearly communicates the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 4 parameters, no output schema, and no annotations, the description is completely inadequate. It doesn't explain what the tool does with the prompt, expected output, or any prerequisites, making it insufficient for an agent to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for all 4 parameters, so baseline is 3. The description adds no parameter-specific meaning beyond what the schema already provides, but no compensation is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description says 'Enhanced context analysis with AI-powered relevance scoring and vector search,' indicating it analyzes context and adds AI features, but it lacks a specific verb+resource and doesn't mention that the context is for Optimizely. It also doesn't distinguish this from sibling tools like optidev_code_analyzer.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives. The description doesn't mention prerequisites, alternatives, or any use-case context, leaving the agent without a basis for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Provides intelligent debugging assistance for Optimizely-related issues
| Name | Required | Description | Default |
|---|---|---|---|
| codeContext | No | Optional relevant code snippets | |
| errorMessages | No | Optional error messages or stack traces | |
| bugDescription | Yes | Description of the bug or issue encountered |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description only says it 'provides intelligent debugging assistance.' It does not disclose what the tool does with the provided inputs, whether it returns suggestions or only analyzes, or whether it is read-only.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence, but it is under-specified. The brevity omits important details that would help an agent use the tool effectively, so it reads more like a placeholder than a well-crafted summary.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, no annotations, and only a generic description, the tool lacks sufficient context. It does not explain what the output looks like, when to invoke it, or how it integrates with the sibling tools, making it incomplete for reliable selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema documents all three parameters with descriptions, covering 100% of the parameter semantics. The tool description adds no additional meaning or context beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description introduces the tool as providing 'debugging assistance for Optimizely-related issues,' which signals a general purpose. However, the phrase 'intelligent debugging assistance' is vague and does not clearly differentiate it from sibling tools like optidev_code_analyzer or optidev_context_analyzer.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers no guidance on when to use this tool versus the alternatives. It does not mention that it should be used for errors/bugs, nor does it specify situations where another tool would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Analyzes Jira tickets and provides complete implementation guidance
| Name | Required | Description | Default |
|---|---|---|---|
| ticketContent | Yes | Jira ticket content or requirements text | |
| projectContext | No | Optional project context or existing codebase information |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must carry the full burden of behavioral disclosure. It states 'analyzes' and 'provides guidance,' but does not disclose whether the tool has side effects, requires authentication, or what the output format is. The word 'complete' overpromises without specifying boundaries, leaving the agent uncertain about the actual behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence: 'Analyzes Jira tickets and provides complete implementation guidance.' There is zero wasted text, and it immediately communicates the core function. It is appropriately sized for the tool's apparent simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 2 parameters, no output schema, and no annotations, the description is too sparse to be complete. It does not explain what 'complete implementation guidance' includes, what the output looks like, or how this tool differs from the sibling tools. The schema helps with parameters, but the overall behavior remains underspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema descriptions cover 100% of parameters (ticketContent and projectContext) with clear explanations. The tool description adds no additional meaning beyond the schema, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool analyzes Jira tickets and provides implementation guidance, which specifies the resource (Jira tickets) and the outcome (guidance). It is distinct from sibling tools like debug_helper or code_analyzer, though it doesn't explicitly name them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The usage context is implied: use when you have Jira tickets and need implementation guidance. However, there is no explicit when-not-to-use, no comparison to alternatives, and no mention of prerequisites (e.g., Is projectContext required?). This is typical of a tool with implied usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Project setup, migration assistance, and development guidance
| Name | Required | Description | Default |
|---|---|---|---|
| requestType | Yes | Type of project assistance needed | |
| targetVersion | No | Target Optimizely version (if applicable) | |
| projectDetails | Yes | Project requirements or current setup details |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only lists service areas ('setup', 'migration', 'development guidance') without describing any side effects, permissions, or what actions will be performed. For a tool that likely mutates project state, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a short, front-loaded phrase, making it easy to read. However, it is under-specified for the tool's complexity—it does not explain the enum values, expected inputs, or behavior. It is concise but not useful enough to be considered well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no annotations, no output schema, and an enum of request types, the description should clarify how each requestType maps to behaviors and what the agent should expect. The description is merely a list of service areas and does not help the agent select parameters or interpret results, leaving the overall context incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers all three parameters with descriptions (requestType enum, targetVersion, projectDetails), giving 100% schema coverage. The tool description adds no parameter-level meaning, so the baseline of 3 is appropriate. No contradictions or extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description lists three broad capabilities ('Project setup, migration assistance, and development guidance') but lacks a specific verb+resource construction. It does not clearly distinguish itself from sibling tools like optidev_context_analyzer or optidev_implementation_guide, so the agent cannot confidently infer what unique outcomes this tool produces.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives. It implies setup/migration/config scenarios but does not state exclusions, prerequisites, or mention sibling tools. The agent is left to infer usage context without support.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Several tools have overlapping purposes: implementation_guide and project_helper both provide development guidance, while code_analyzer and debug_helper both analyze code for issues. Descriptions clarify some boundaries but ambiguity remains, especially for agents relying on tool names alone.
All tools follow a consistent optidev_<topic>_<role> pattern (analyzer, guide, helper) and use snake_case throughout. The convention is uniform and predictable, even though it uses nouns rather than verbs.
With exactly 5 tools, the server is well-scoped for a development assistance purpose. Each tool covers a distinct area without unnecessary duplication, making the set manageable and purposeful.
The toolset covers key development assistance needs: context analysis, implementation guidance, debugging, code analysis, and project setup. Minor gaps exist (e.g., testing or deployment guidance), but core workflows are well represented.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
One shared context your team's AI tools read & write over MCP. No re-explaining. Free.
The OpenZeppelin Solidity Contracts MCP server integrates OpenZeppelin's security and style rules into AI-driven development workflows, enabling AI assistants to generate safe, correct, and production-ready smart contracts. It automatically validates generated code against OpenZeppelin standards (including imports, modifiers, naming conventions, and security checks) and supports various contract types including ERC-20, ERC-721, ERC-1155, Stablecoins, RWA, Governor, and Account contracts through prompt-driven workflows.
The OpenZeppelin Cairo Contracts MCP server generates secure smart contracts in the Cairo language for Starknet environments based on OpenZeppelin templates. It brings OpenZeppelin's proven security and style rules directly into AI-driven development workflows to create safe, production-ready contracts. Key capabilities include providing templates for ERC-20, ERC-721, ERC-1155, Multisig, Governor, and Vesting contracts.
Analytics your AI agent can actually use. Track, experiment, and optimize via MCP.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/biswajitpanday/Optivise'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
