Skip to main content
Glama
Dhi13man
by Dhi13man

OOREP MCP Server

npm version CI CodeQL OpenSSF Scorecard License: MIT

An MCP server and TypeScript client SDK that gives AI assistants access to OOREP's homeopathic repertory and materia medica reference data.

TL;DR

# Install and run (no setup required)
npx -y oorep-mcp
// Or use programmatically
import { createOOREPClient } from 'oorep-mcp';

const client = createOOREPClient();
const results = await client.searchRepertory({ symptom: 'headache worse motion' });
console.log(results.rubrics);
client.destroy();

Ask your AI assistant: "Search OOREP for remedies for throbbing headache worse from light"

Related MCP server: Swagger MCP Adapter

What is OOREP?

OOREP (Open Online Repertory) is an open-source homeopathic database containing:

  • 12+ Repertories - Systematic indexes of symptoms mapped to remedies (Kent, Boger, Boericke, etc.)

  • Multiple Materia Medicas - Detailed remedy descriptions and therapeutic indications

  • 600+ Remedies - Comprehensive remedy database with names, abbreviations, and alternates

How Homeopathic Data is Structured

graph TB
    subgraph Repertory[Repertory Structure]
        Chapter[Chapter<br/>e.g. Head]
        Rubric[Rubric<br/>e.g. Pain - Throbbing]
        R1[Belladonna - 4]
        R2[Glonoine - 3]
        R3[Natrum mur - 2]
        Chapter --> Rubric
        Rubric --> R1
        Rubric --> R2
        Rubric --> R3
    end

    subgraph MateriaMedica[Materia Medica Structure]
        Remedy[Remedy<br/>e.g. Belladonna]
        S1[Mind: Sudden onset...]
        S2[Head: Throbbing pain...]
        S3[...]
        Remedy --> S1
        Remedy --> S2
        Remedy --> S3
    end

This MCP server enables AI assistants to query this data programmatically.

Features

Feature

Description

Search Repertories

Query symptoms across 12+ repertories, get matching rubrics with weighted remedies

Search Materia Medicas

Find remedy descriptions and indications from multiple sources

Remedy Information

Get comprehensive details for 600+ remedies

List Resources

Browse available repertories, materia medicas, and remedies

Guided Workflows

Prompts for symptom analysis, remedy comparison, case repertorization

Structured Responses

MCP 2025-06-18 compliant with outputSchema and structuredContent

Performance

Built-in caching (5min TTL), request deduplication, automatic retries

Type Safety

Full TypeScript with Zod validation on all inputs

Security

Input sanitization, error message sanitization, no credentials required

SDK Adapters

Direct integration with OpenAI, Vercel AI SDK, LangChain, Google Gemini

Quick Start

Requires Node.js 22.12 or newer with npm/npx.

1. Add to Claude Desktop

macOS: Edit ~/Library/Application Support/Claude/claude_desktop_config.json Windows: Edit %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "oorep": {
      "command": "npx",
      "args": ["-y", "oorep-mcp"]
    }
  }
}

2. Restart Claude Desktop

Quit completely (Cmd+Q / Alt+F4), then reopen.

3. Start Using

You: "Search OOREP for remedies for headache worse at night"

Claude will:

  1. Call search_repertory with symptom "headache worse night"

  2. Return matching rubrics with remedies and their weights

  3. Explain the results in context

Installation

No installation required:

npx -y oorep-mcp

npm Global

npm install -g oorep-mcp
oorep-mcp

npm Local (for SDK usage)

npm install oorep-mcp

Platform Configuration

Claude Code

Option A: CLI

claude mcp add oorep -- npx -y oorep-mcp

Option B: Config file (~/.claude.json)

{
  "mcpServers": {
    "oorep": {
      "command": "npx",
      "args": ["-y", "oorep-mcp"],
      "env": {
        "OOREP_MCP_BASE_URL": "https://www.oorep.com",
        "OOREP_MCP_LOG_LEVEL": "info"
      }
    }
  }
}

Verify: Run /mcp in Claude Code

Claude Desktop

Config locations:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "oorep": {
      "command": "npx",
      "args": ["-y", "oorep-mcp"],
      "env": {
        "OOREP_MCP_BASE_URL": "https://www.oorep.com",
        "OOREP_MCP_LOG_LEVEL": "info"
      }
    }
  }
}

Important: Quit completely (Cmd+Q), not just close window.

Codex CLI

Config: ~/.codex/config.toml (macOS/Linux) or C:\Users\<Username>\.codex\config.toml (Windows)

[mcp_servers.oorep]
command = "npx"
args = ["-y", "oorep-mcp"]
startup_timeout_sec = 15.0
tool_timeout_sec = 60.0

[mcp_servers.oorep.env]
OOREP_MCP_BASE_URL = "https://www.oorep.com"
OOREP_MCP_LOG_LEVEL = "info"

Or via CLI:

codex mcp add oorep --env OOREP_MCP_BASE_URL=https://www.oorep.com --env OOREP_MCP_LOG_LEVEL=info -- npx -y oorep-mcp

Verify: Run codex mcp list

Gemini CLI

Config: ~/.gemini/settings.json

{
  "mcpServers": {
    "oorep": {
      "command": "npx",
      "args": ["-y", "oorep-mcp"],
      "env": {
        "OOREP_MCP_BASE_URL": "https://www.oorep.com",
        "OOREP_MCP_LOG_LEVEL": "info"
      },
      "timeout": 30000
    }
  }
}

Usage Examples

Once installed, you can interact with OOREP through Claude naturally:

Searching for Remedies

You: "Can you search OOREP for remedies for headache that's worse at night?"

Claude will:

  1. Use the search_repertory tool

  2. Search for "headache worse night" in the default repertory

  3. Return matching rubrics with remedy recommendations and their weights

Getting Detailed Remedy Information

You: "Tell me more about Aconite - what conditions is it used for?"

Claude will:

  1. Use the get_remedy_info tool to fetch details about Aconite

  2. Provide information about its common uses, characteristics, and therapeutic applications

Comparing Remedies

You: "Compare Aconite and Belladonna for fever symptoms"

Claude will:

  1. Use the remedy-comparison prompt

  2. Search materia medicas for both remedies

  3. Provide a side-by-side comparison focusing on fever symptoms

  4. Highlight key differentiating factors

Case Repertorization

You: "I want to repertorize a case with these symptoms: anxiety, palpitations, and insomnia"

Claude will:

  1. Use the repertorization-workflow prompt

  2. Guide you through systematic symptom analysis

  3. Search relevant rubrics for each symptom

  4. Help synthesize results to identify well-indicated remedies

Browsing Available Resources

You: "What repertories are available in OOREP?"

Claude will:

  1. Use the list_available_repertories tool

  2. Show all 12+ available repertories with their names and descriptions

API Reference

Tools

search_repertory

Search for symptoms in homeopathic repertories.

Parameters:

Name

Type

Required

Default

Description

symptom

string

Yes

-

Symptom to search (3-200 chars). Supports wildcards.

repertory

string

No

publicum

Repertory abbreviation (e.g., kent, boger)

minWeight

number

No

1

Minimum remedy weight (1-4)

maxResults

number

No

20

Maximum rubrics to return (1-100)

includeRemedyStats

boolean

No

true

Include aggregated remedy statistics

Returns:

{
  totalResults: number;
  rubrics: Array<{
    rubric: string;           // Full path: "Head > Pain > Throbbing"
    text: string | null;      // Additional rubric text
    repertory: string;        // Repertory abbreviation
    remedies: Array<{
      name: string;           // Full name: "Belladonna"
      abbreviation: string;   // "Bell."
      weight: number;         // 1-4
    }>;
  }>;
  remedyStats?: Array<{       // If includeRemedyStats=true
    name: string;
    abbreviation: string;
    count: number;            // Times appearing
    cumulativeWeight: number; // Sum of weights
  }>;
}

search_materia_medica

Search materia medica texts for remedy descriptions.

Parameters:

Name

Type

Required

Default

Description

symptom

string

Yes

-

Symptom to search (3-200 chars)

materiamedica

string

No

boericke

Materia medica abbreviation

remedy

string

No

-

Filter to specific remedy

maxResults

number

No

10

Maximum results (1-50)

Returns:

{
  totalResults: number;
  results: Array<{
    remedy: string;           // "Aconitum napellus"
    materiaMedica: string;    // "boericke"
    sections: Array<{
      heading: string;        // "Mind", "Head", etc.
      content: string;        // Section text
      depth: number;          // Heading depth
    }>;
  }>;
}

get_remedy_info

Get detailed information about a specific remedy.

Parameters:

Name

Type

Required

Description

remedy

string

Yes

Remedy name, abbreviation, or alternate name (1-100 chars)

Returns:

{
  id: number;
  nameAbbrev: string;    // "Acon."
  nameLong: string;      // "Aconitum napellus"
  namealt: string[];     // ["Aconite", "Monkshood"]
} | null  // null if not found

Matching behavior:

  • Exact match on abbreviation, long name, or alternate names (case-insensitive)

  • Partial match for queries ≥3 characters

list_available_repertories

List all accessible repertories.

Parameters:

Name

Type

Required

Description

language

string

No

Filter by language code (e.g., en, de)

Returns:

Array<{
  abbreviation: string;  // "kent"
  title: string;         // "Kent Repertory"
  author: string;        // "James Tyler Kent"
  language: string;      // "en"
}>

list_available_materia_medicas

List all accessible materia medica texts.

Parameters:

Name

Type

Required

Description

language

string

No

Filter by language code

Returns:

Array<{
  abbreviation: string;  // "boericke"
  title: string;         // "Boericke Materia Medica"
  author: string;        // "William Boericke"
  language: string;      // "en"
}>

Structured Response Format

All tools support the MCP 2025-06-18 specification with structured responses:

Response Structure:

{
  // Text content for backwards compatibility
  content: [{
    type: 'text',
    text: '{"totalResults": 42, "rubrics": [...]}' // JSON string
  }],

  // Machine-parseable structured content
  structuredContent: {
    totalResults: 42,
    rubrics: [...]  // Actual JavaScript object
  }
}

Benefits:

  • outputSchema: Each tool definition includes a JSON Schema defining the expected output structure

  • structuredContent: Direct access to typed results without JSON parsing

  • Backwards Compatible: Text content always included for older clients

  • Error Handling: Errors return isError: true for LLM self-correction

Resources

URI

Description

Content Type

oorep://remedies/list

Complete list of all 600+ remedies

JSON

oorep://repertories/list

All available repertories with metadata

JSON

oorep://materia-medicas/list

All available materia medicas

JSON

oorep://help/search-syntax

Search syntax guide with examples

Text

Prompts

analyze-symptoms

Guided workflow for systematic symptom analysis.

Arguments:

Name

Type

Required

Description

symptom_description

string

No

Initial symptom description

Workflow: Guides through symptom gathering → modality analysis → repertory search → synthesis

remedy-comparison

Compare multiple remedies side-by-side.

Arguments:

Name

Type

Required

Description

remedies

string

Yes

Comma-separated remedy names (2-6 remedies)

Example: remedies: "Aconite, Belladonna, Gelsemium"

repertorization-workflow

Step-by-step case taking and repertorization.

Workflow: 7-step process from symptom collection through remedy differentiation.

Search Syntax

headache                    # Simple term
headache night              # Multiple terms (AND)

Wildcards

head*                       # Matches: head, headache, heading
*ache                       # Matches: headache, stomachache

Exact Phrases

"worse at night"            # Exact phrase match
"throbbing pain"            # Must appear together

Exclusions

headache -migraine          # Headache but not migraine
fever -intermittent         # Fever excluding intermittent

Combined

head* pain -chronic "worse motion"

Tips

  • Minimum 3 characters per term

  • Wildcards only at word boundaries

  • Use repertory-specific terminology for better results

SDK Integration

For programmatic use with AI frameworks, see the SDK Integration Guide.

Supported frameworks: OpenAI, Vercel AI SDK, LangChain/LangGraph, Google Gemini

Quick example:

import { createOOREPClient } from 'oorep-mcp';

const client = createOOREPClient();
const results = await client.searchRepertory({ symptom: 'headache worse motion' });
console.log(results.rubrics);
client.destroy();

Configuration

All configuration via environment variables:

Variable

Default

Description

OOREP_MCP_BASE_URL

https://www.oorep.com

OOREP API base URL

OOREP_MCP_TIMEOUT_MS

30000

Request timeout (ms)

OOREP_MCP_CACHE_TTL_MS

300000

Cache TTL (ms), 0 to disable

OOREP_MCP_MAX_RESULTS

100

Maximum results cap

OOREP_MCP_LOG_LEVEL

info

debug | info | warn | error

OOREP_MCP_DEFAULT_REPERTORY

publicum

Default repertory

OOREP_MCP_DEFAULT_MATERIA_MEDICA

boericke

Default materia medica

OOREP_MCP_REMOTE_USER

(unset)

If set, sends X-Remote-User header (numeric member ID) on all upstream requests

The MCP server maintains an anonymous OOREP session automatically. It performs a lightweight bootstrap request to fetch the required cookies and reuses them for subsequent search calls, so no additional authentication setup is necessary for public data.

Example with custom config:

{
  "mcpServers": {
    "oorep": {
      "command": "npx",
      "args": ["-y", "oorep-mcp"],
      "env": {
        "OOREP_MCP_TIMEOUT_MS": "60000",
        "OOREP_MCP_CACHE_TTL_MS": "600000",
        "OOREP_MCP_LOG_LEVEL": "debug"
      }
    }
  }
}

Architecture

graph TB
    subgraph Client[MCP Client]
        MCPClient((Claude, Codex,<br/>Gemini, etc.))
    end

    subgraph Server[OOREP MCP Server]
        Tools[Tools]
        Resources[Resources]
        Prompts[Prompts]
        SDK[SDK]

        subgraph SDKClient[OOREPClient]
            Cache[(Cache)]
            Dedup[Deduplicator]
            Validators[Validators]
        end

        subgraph HTTPClient[OOREPClient - HTTP]
            Session[Session mgmt]
            Retry[Retry logic]
            Timeout[Timeout handling]
        end

        Tools --> SDKClient
        Resources --> SDKClient
        Prompts --> SDKClient
        SDK --> SDKClient
        SDKClient --> HTTPClient
    end

    subgraph External[OOREP API]
        API[https://www.oorep.com]
    end

    MCPClient -->|MCP Protocol| Server
    HTTPClient -->|HTTPS| API

Key Components:

  • Cache: In-memory LRU cache with configurable TTL (default 5 min)

  • Deduplicator: Prevents duplicate concurrent requests for same data

  • Validators: Zod schemas validate all inputs before API calls

  • Session Management: Automatic cookie handling for OOREP API

Security Considerations

Input Validation

All inputs are validated using Zod schemas:

  • Symptom searches: 3-200 characters, trimmed of whitespace

  • Remedy names: 1-100 characters

  • Server-side sanitization: The OOREP API handles additional input sanitization

Error Handling

  • All errors are sanitized before being returned to clients

  • Internal details (stack traces, file paths) are never exposed

  • Network errors return generic messages

Data Privacy

  • No user credentials are stored or required

  • OOREP sessions are anonymous and cookie-based

  • No data is persisted to disk (memory cache only)

  • All inputs validated using Zod schemas

  • Errors are sanitized before returning to clients

Rate Limiting

The OOREP MCP Server does not implement internal rate limiting. However:

OOREP API Limits

The upstream OOREP API may have rate limits. If you exceed them, you'll receive a RateLimitError:

{
  content: [{ type: 'text', text: 'Error: Rate limit exceeded. Please try again later.' }],
  isError: true
}

Mitigation Strategies

  1. Enable caching (default: 5 minutes TTL)

    "env": { "OOREP_MCP_CACHE_TTL_MS": "300000" }
  2. Reduce concurrent requests by using specific search terms

  3. Increase cache TTL for frequently accessed data

    "env": { "OOREP_MCP_CACHE_TTL_MS": "600000" }

Request Deduplication

The SDK client automatically deduplicates concurrent identical requests, reducing API load.

TypeScript Type Imports

Import types directly from the package for type-safe development:

import type {
  // Tool argument types
  SearchRepertoryArgs,
  SearchMateriaMedicaArgs,
  GetRemedyInfoArgs,
  ListRepertoriesArgs,
  ListMateriaMedicasArgs,

  // Result types
  RepertorySearchResult,
  MateriaMedicaSearchResult,
  RemedyInfo,
  RepertoryMetadata,
  MateriaMedicaMetadata,

  // Supporting types
  Rubric,
  Remedy,
  MateriaMedicaResult,
  MateriaMedicaSection,
  // SDK Client types
  OOREPClient,
  OOREPSDKConfig,
} from 'oorep-mcp';

Schema Validation

You can also import Zod schemas for runtime validation:

import {
  SearchRepertoryArgsSchema,
  RepertorySearchResultSchema,
  RemedyInfoSchema,
} from 'oorep-mcp';

// Validate external data
const validated = SearchRepertoryArgsSchema.parse(untrustedInput);

Troubleshooting

Server Not Appearing in Claude Desktop

Problem: The MCP indicator doesn't show up after configuration.

Solutions:

  1. Completely quit Claude Desktop (Cmd+Q on macOS, not just close window)

  2. Restart Claude Desktop and wait 10-15 seconds for MCP initialization

  3. Check the configuration file for valid JSON syntax (use a JSON validator)

  4. Check the logs:

    • macOS: ~/Library/Logs/Claude/mcp*.log

    • Windows: %APPDATA%\Claude\Logs\mcp*.log

  5. Verify npx works: Run npx -y oorep-mcp in terminal to check if it starts

Connection Timeout Errors

Problem: "Connection timeout" or "Request timed out" errors.

Solutions:

  1. Increase timeout in configuration:

    "env": {
      "OOREP_MCP_TIMEOUT_MS": "60000"
    }
  2. Check network connectivity to https://www.oorep.com:

    curl https://www.oorep.com
  3. Check for firewall/proxy issues that might block connections

No Results Returned

Problem: Searches return empty results or "No results found".

Solutions:

  1. Try broader search terms (e.g., "headache" instead of "headache left temple worse 3pm")

  2. Remove filters like minWeight or specific repertory restrictions

  3. Check if OOREP website is accessible at https://www.oorep.com

  4. Try a different repertory: Ask Claude: "Search in the Kent repertory instead"

High Memory Usage

Problem: MCP server consuming excessive memory.

Solutions:

  1. Reduce cache TTL to clear cache more frequently:

    "env": {
      "OOREP_MCP_CACHE_TTL_MS": "60000"
    }
  2. Reduce max results:

    "env": {
      "OOREP_MCP_MAX_RESULTS": "50"
    }
  3. Restart Claude Desktop periodically to clear cache

Permission Errors on macOS/Linux

Problem: "Permission denied" when running the server.

Solutions:

  1. For global install: Ensure proper npm permissions

    sudo npm install -g oorep-mcp
  2. For npx (recommended): No permissions needed, use -y flag:

    npx -y oorep-mcp

Viewing Detailed Logs

To see detailed debug logs for troubleshooting:

  1. Set log level to debug:

    "env": {
      "OOREP_MCP_LOG_LEVEL": "debug"
    }
  2. Check MCP logs:

    • macOS: tail -f ~/Library/Logs/Claude/mcp*.log

    • Windows: Check %APPDATA%\Claude\Logs\

  3. Look for specific error patterns:

    • NetworkError - Connection issues

    • TimeoutError - Request taking too long

    • ValidationError - Invalid input

    • RateLimitError - Too many requests

Still Having Issues?

  1. Check existing issues: https://github.com/Dhi13man/oorep-mcp/issues

  2. Report a new issue: Include:

    • Your OS and version

    • Node.js version (node --version)

    • Claude Desktop version

    • Configuration (remove any sensitive data)

    • Error logs from MCP log files

  3. Join the discussion: Share your experience and get community help

Development

Prerequisites

  • Node.js ≥ 22.12.0

  • npm ≥ 10.0.0

Setup

git clone https://github.com/Dhi13man/oorep-mcp.git
cd oorep-mcp
npm ci

Commands

npm run build          # Compile TypeScript
npm run typecheck      # Type checking only
npm run dev            # Development mode with watch
npm test               # Run all tests
npm run test:watch     # Watch mode
npm run test:coverage  # Coverage report
npm run test:e2e       # Live OOREP integration (requires network access)
npm run lint           # ESLint
npm run format         # Prettier

Test Structure

src/
├── **/*.unit.test.ts        # Unit tests (mocked dependencies)
└── **/*.integration.test.ts # Integration tests (real implementations)
  • 1100+ tests with 95%+ coverage

  • Unit tests use mocked dependencies

  • Integration tests use real implementations with mocked HTTP

Disclaimer

This tool is for educational and informational purposes only.

  • Not medical advice - Not a substitute for professional medical consultation

  • Consult practitioners - Always consult qualified homeopathic practitioners

  • Not for diagnosis - Not intended for diagnosing or treating medical conditions

Homeopathic treatment should only be undertaken under the guidance of qualified professionals.

License

MIT License - see LICENSE file for details.

Acknowledgments

  • OOREP Team: For creating and maintaining the open-source OOREP platform

  • Anthropic: For the Model Context Protocol and Claude

  • MCP Community: For tools, documentation, and support

Available Tools

5 tools
get_remedy_infoA

Retrieve comprehensive information about a specific homeopathic remedy including its full name, abbreviations, and alternative names. Useful for learning about individual remedies.

ParametersJSON Schema
NameRequiredDescriptionDefault
remedyYesRemedy name or abbreviation (e.g., "Aconite", "Acon.", "Aconitum napellus"). Case-insensitive.

Output Schema

ParametersJSON Schema
NameRequiredDescription
idYes
nameAltNo
nameLongYes
nameAbbrevYes

TDQS

A3.5/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the annotation bar is lowered but the description still carries the disclosure burden. The description is a read operation ('Retrieve... learn') which is implied but not explicitly declared as read-only. It doesn't mention error behavior for unknown remedies, normalization of abbreviations, or response structure. The description adds the 'full name, abbreviations, and alternative names' scope, which is useful but modest.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with the core purpose immediately. No wasted words or redundancy. The final sentence is a mild filler ('Useful for learning about individual remedies') but not egregious. Appropriately compact for what it conveys.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is relatively simple (1 parameter, clear schema, output schema present). The description covers the purpose and the scope of returned info (name, abbreviations, alternative names). However, it doesn't note behavior for invalid/unknown remedy names, which would be helpful given lookups commonly encounter typos. Output schema exists so return-value documentation isn't required. Adequate but not rich.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the blueprint for the remedy parameter is well documented with examples (Aconite, Acon., Aconitum napellus) and case-insensitivity. The description adds that it covers 'full name, abbreviations, and alternative names' which maps to the remedy parameter meaning, but the schema already provides the format and examples. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb+resource: "Retrieve comprehensive information about a specific homeopathic remedy" including its full name, abbreviations, and alternative names. It distinguishes from siblings (search_repertory, search_materia_medica) since it's about remedy identity data rather than searching content, though it doesn't explicitly name alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage ('Useful for learning about individual remedies') but doesn't explicitly state when to use this vs search_materia_medica or search_repertory. The distinction is inferable—this retrieves remedy identity/name info, while siblings search remedy content—but no clear 'use this when' or 'use that instead' guidance is given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_available_materia_medicasB

Get a complete list of all available homeopathic materia medicas with their metadata including title, author, and language. Useful for discovering which materia medicas are available for searching.

ParametersJSON Schema
NameRequiredDescriptionDefault
languageNoOptional: Filter materia medicas by language code (e.g., "en" for English, "de" for German). If not specified, returns all materia medicas.

Output Schema

ParametersJSON Schema
NameRequiredDescription
materiaMedicasYes

TDQS

B3.4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full behavioral disclosure burden. It indicates this is a read/discovery operation ('Get a complete list'), which signals non-mutating behavior. However, it doesn't describe the output format, potential pagination/limits, or whether the 'complete list' could be large. The description adds some behavioral context (metadata contents) but lacks depth.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two efficient sentences with no wasted words. The description is front-loaded with the primary purpose and appends a brief usage note. It could arguably trim the final clause, but overall it's well-structured and appropriately compact.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given an output schema exists and one simple optional parameter with full schema coverage, the description is reasonably complete. However, for a discovery tool that lists all items, it doesn't mention potential scale, ordering, or navigation behavior. For the tool's low complexity, it's adequate but leaves some behavioral gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The single parameter 'language' has 100% schema description coverage, with the schema already explaining it's an optional filter by language code with examples. The description says 'returns all materia medicas' if unspecified, which adds slight context about default behavior beyond the schema. However, this mainly restates what the schema already conveys, so baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Get a complete list'), the resource ('all available homeopathic materia medicas'), and the metadata returned (title, author, language). It partially distinguishes itself from siblings by noting it's about discovery rather than searching, which differentiates it from search_materia_medica and search_repertory. However, it doesn't explicitly contrast with list_available_repertories, a close sibling.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description notes it is 'Useful for discovering which materia medicas are available for searching,' implying usage in a discovery/discovery-before-search workflow. However, it lacks explicit when-to-use vs when-not-to-use guidance or explicit exclusion of alternatives like search_materia_medica. The implied guidance is helpful but not explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_available_repertoriesA

Get a complete list of all available homeopathic repertories with their metadata including title, author, and language. Useful for discovering which repertories are available for searching.

ParametersJSON Schema
NameRequiredDescriptionDefault
languageNoOptional: Filter repertories by language code (e.g., "en" for English, "de" for German). If not specified, returns all repertories.

Output Schema

ParametersJSON Schema
NameRequiredDescription
repertoriesYes

TDQS

A4.3/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden of behavioral disclosure. It's a read-only listing operation that is non-destructive, and the description's non-mutating language ('Get', 'discovering') is consistent. However, it doesn't describe pagination, ordering, or any limits, though as a listing tool with output schema present, the bar is moderate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, zero waste. The description front-loads the primary purpose and metadata fields, then adds the discoverability use-case. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple single-optional-parameter listing tool with a full input schema and an output schema present, the description is complete. It conveys purpose, schema covers the parameter, and the return metadata (title, author, language) is stated.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% (the single optional 'language' parameter is fully documented). The description reinforces that language is optional and clarifies its default behavior ('If not specified, returns all repertories'), adding meaning beyond the schema's format constraint.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clear verb+resource: 'Get a complete list of all available homeopathic repertories with their metadata including title, author, and language.' The description explicitly names what metadata is returned and distinguishes this from sibling tools like list_available_materia_medicas and the search tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

States it is 'useful for discovering which repertories are available for searching,' implying it should be used as a precursor to search_repertory. It doesn't explicitly exclude sibling tools (list_available_materia_medicas), though the 'repertories' vs 'materia_medicas' contrast is implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_materia_medicaA

Search materia medica texts for symptoms and return matching remedy sections. Materia medicas provide detailed descriptions of remedy characteristics, symptoms, and clinical applications. Useful for in-depth remedy study and comparison.

ParametersJSON Schema
NameRequiredDescriptionDefault
remedyNoOptional: Filter results to a specific remedy (e.g., "Aconite", "Belladonna"). Useful for focused remedy study.
symptomYesSearch term for symptoms or characteristics (3-200 characters). Examples: "fever", "anxiety", "headache worse night"
maxResultsNoOptional: Maximum number of remedy results to return (1-500). Defaults to OOREP_MCP_MAX_RESULTS (100) when omitted.
materiamedicaNoOptional: Filter by specific materia medica abbreviation. Use list_available_materia_medicas to discover options. If not specified, uses the configured default materia medica (OOREP_MCP_DEFAULT_MATERIA_MEDICA).

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultsYes
totalResultsYes

TDQS

A3.5/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the behavioral burden. The description explains what materia medicas are and the tool's purpose but doesn't disclose return behavior, volume of results, or what happens when no matches are found. The output schema exists which helps, but for a search tool with no annotations, richer behavioral context (e.g., result format, default filtering) would help.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, reasonably compact, and front-loaded with the core purpose. The second sentence ('Materia medicas provide detailed descriptions...') adds helpful context for a knowledge domain that may be unfamiliar. Slightly redundant but not wasteful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With a 100% schema coverage, an output schema, and a reasonable description that orients the agent to the domain, this is fairly complete. The description explains the domain value, the parameters are well-documented in the schema, and an output schema exists. The main gap is the lack of alternative-tool guidance (search_repertory contrast).

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all four parameters thoroughly with clear descriptions and examples. The tool description adds minimal parameter context beyond the schema. Baseline 3 is appropriate since the schema does the heavy lifting and the description doesn't need to duplicate it.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states the verb (search), resource (materia medica texts), and outcome (matching remedy sections). It adds context about what materia medicas provide ('detailed descriptions of remedy characteristics, symptoms, clinical applications'). However, it could better distinguish from sibling search_repertory - the description notes it's 'useful for in-depth remedy study and comparison' but doesn't explicitly contrast with a repertory search.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit when-to-use or when-not-to-use guidance, and no alternative tools are named. The description implies usage through context ('useful for in-depth remedy study and comparison') but doesn't tell the agent when to prefer this over search_repertory or get_remedy_info. Sibling differentiation must be inferred rather than stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_repertoryA

Search for symptoms in homeopathic repertories and return matching rubrics with remedies. Supports wildcards (*), exclusions (-), and exact phrases ("). Returns rubrics sorted by relevance with remedies and their weights.

ParametersJSON Schema
NameRequiredDescriptionDefault
symptomYesSearch term for symptoms (3-200 characters). Supports wildcards (*), exclusions (-term), and exact phrases ("phrase"). Examples: "headache", "head*", "fever -night", '"worse from cold"'
minWeightNoOptional: Minimum remedy weight/grade to include (1-4). Higher weights indicate stronger associations. 1=slight, 2=moderate, 3=strong, 4=very strong
repertoryNoOptional: Filter by specific repertory abbreviation. Use list_available_repertories to discover options. If not specified, uses the configured default repertory (OOREP_MCP_DEFAULT_REPERTORY).
maxResultsNoOptional: Maximum number of results to return (1-500). Defaults to OOREP_MCP_MAX_RESULTS (100) when omitted.
includeRemedyStatsNoOptional: Include aggregate remedy statistics showing which remedies appear most frequently. Default: true

Output Schema

ParametersJSON Schema
NameRequiredDescription
rubricsYes
totalPagesNo
currentPageNo
remedyStatsNo
totalResultsYes

TDQS

A4.3/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses that results are sorted by relevance, that remedies come with weights, and describes the default repertory behavior when repertory param is omitted. However, it doesn't describe pagination behavior or what the detailed output schema contains beyond rubrics/remedies/weights, which is partially covered by the output schema existing.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, both informative. The first establishes purpose and the search syntax; the second describes output format and behavior. No wasted words, though it could add a brief note about when to use this vs search_materia_medica without breaking its economy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of an output schema, the description doesn't need to detail return values. However, with 5 parameters, no annotations, and a moderately complex query language, the description captures the essentials but leaves gaps around result size behavior, pagination, and error handling when no matches are found. Slightly above minimal viable given the output schema exists.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema does substantial work for all 5 parameters. The description adds value by explaining the overall search syntax (wildcards, exclusions, exact phrases) and the output structure (rubrics with remedies sorted by relevance). It supplements rather than duplicates the schema's parameter documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Uses specific verb 'search' with a clear resource 'homeopathic repertories', states what it returns (matching rubrics with remedies), and explains output ordering (by relevance with weights). Distinguishes from siblings by specifying repertories specifically vs. materia medica, making it clear which sibling to use.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description clearly states what the tool does and the input syntax (wildcards, exclusions, exact phrases). However, it doesn't explicitly say when NOT to use it or mention that search_materia_medica is the alternative for materia medica searches. The repertory parameter references list_available_repertories for discovery, providing some guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 5 tool updatesv1.2.3
    • First observedget_remedy_info
    • First observedlist_available_materia_medicas
    • First observedlist_available_repertories
    • First observedsearch_materia_medica
    • First observedsearch_repertory

TDQS

A3.9/5.0

Scored across 5 tools

Disambiguation5/5

Each tool targets a distinct resource and action: two search tools (repertory vs materia medica), a remedy info retrieval tool, and two list tools (repertories vs materia medicas). There is clear separation between discovery (list_*) and usage (search_*, get_*) functions.

Naming Consistency4/5

Nearly all tools follow a verb_noun pattern (search_repertory, search_materia_medica, get_remedy_info, list_available_*). Minor inconsistency: two tools use singular (search_repertory, search_materia_medica) while their corresponding list tools use plural (repertories, materia_medicas), which is slightly inconsistent but understandable.

Tool Count5/5

Five tools is a well-scoped count for a homeopathic reference server. Each tool serves a distinct purpose covering search, lookup, and discovery without redundancy or bloat.

Completeness4/5

The tool surface covers the core workflows: discover available repertories/materia medicas, search for symptoms in repertories, search detailed materia medica texts, and retrieve individual remedy info. A minor gap is the lack of a dedicated search-within-remedy or remedy comparison tool, but the primary use cases are covered.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • F
    license
    Not graded
    quality
    D
    maintenance
    An MCP server and web application that enables natural language medical queries and patient data analysis powered by Gemini AI. It allows users to track and analyze patient biometrics, including vitals, sleep patterns, and laboratory results, through a comprehensive set of automated medical tools.
    -
  • A
    license
    Not graded
    quality
    C
    maintenance
    MCP server for CITED Health that allows AI assistants to query evidence-based supplement data, including ingredient evidence grades, health conditions, PubMed papers, glossary terms, and educational guides.
    MIT