Obenan MCP Server
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., "@Obenan MCP Serveradd a note named 'meeting notes' with the content 'discussed project timeline and deliverables'"
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.
obenan-mcp-server MCP server
obenan mcp server
Components
Resources
The server implements a simple note storage system with:
Custom note:// URI scheme for accessing individual notes
Each note resource has a name, description and text/plain mimetype
Prompts
The server provides a single prompt:
summarize-notes: Creates summaries of all stored notes
Optional "style" argument to control detail level (brief/detailed)
Generates prompt combining all current notes with style preference
Tools
The server implements one tool:
add-note: Adds a new note to the server
Takes "name" and "content" as required string arguments
Updates server state and notifies clients of resource changes
Related MCP server: browser-use MCP server
Configuration
[TODO: Add configuration details specific to your implementation]
Quickstart
Install
Claude Desktop
On MacOS: ~/Library/Application\ Support/Claude/claude_desktop_config.json
On Windows: %APPDATA%/Claude/claude_desktop_config.json
Development
Building and Publishing
To prepare the package for distribution:
Sync dependencies and update lockfile:
uv syncBuild package distributions:
uv buildThis will create source and wheel distributions in the dist/ directory.
Publish to PyPI:
uv publishNote: You'll need to set PyPI credentials via environment variables or command flags:
Token:
--tokenorUV_PUBLISH_TOKENOr username/password:
--username/UV_PUBLISH_USERNAMEand--password/UV_PUBLISH_PASSWORD
Debugging
Since MCP servers run over stdio, debugging can be challenging. For the best debugging experience, we strongly recommend using the MCP Inspector.
You can launch the MCP Inspector via npm with this command:
npx @modelcontextprotocol/inspector uv --directory /Users/AhmedUmerAnees/code/obenan-mcp-server run obenan-mcp-serverUpon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
Available Tools
4 toolsfetch_my_locationsC
Fetch locations from Obenan API using the access token
| Name | Required | Description | Default |
|---|---|---|---|
| access_token | No | Access token for Obenan API. Optional if OBENAN_LOGIN_ACCESS_TOKEN environment variable is set. | |
| group_id | No | Group ID to filter locations by. Optional. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full disclosure burden but provides minimal behavioral context. It mentions authentication (access token) but omits what data structure is returned, pagination behavior, rate limits, or error conditions. The agent cannot determine if this is a safe read operation or what fields the locations contain.
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?
Extremely concise at 9 words in a single sentence. Front-loaded with verb 'Fetch'. While no words are wasted, the brevity crosses into under-specification given the lack of annotations and output schema. Appropriate density but insufficient length for the complexity.
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 the presence of multiple location-related siblings and no output schema, the description inadequately prepares the agent for tool selection. It fails to explain return values, distinguish this list operation from single-record retrieval, or document authentication requirements beyond the parameter itself.
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?
Input schema has 100% description coverage, establishing a baseline of 3. The description adds no additional parameter semantics beyond mentioning the access token (already documented in schema). It does not explain the relationship between group_id and the returned locations or provide usage examples.
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 states the basic action (Fetch locations) and target API (Obenan), matching the tool name's intent. However, it fails to clarify the 'my' aspect (user-specific locations vs. public/global) or distinguish from siblings like 'get_location_details' and 'search_locations_by_name', leaving ambiguity about scope and return cardinality.
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 provided on when to use this tool versus the three sibling location tools. The description does not indicate whether this returns a list vs. single record, or when to prefer searching by name versus fetching 'my' locations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_location_detailsC
Get detailed information about a specific location by ID
| Name | Required | Description | Default |
|---|---|---|---|
| location_id | Yes | ID of the location to get details for | |
| access_token | No | Access token for Obenan API. Optional if OBENAN_LOGIN_ACCESS_TOKEN environment variable is set. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure but fails to address idempotency, error handling (e.g., 404 for invalid IDs), what constitutes 'detailed information,' or specific auth requirements beyond the parameter name.
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 with no redundancy. However, it is arguably underspecified given the lack of annotations and output schema, though structurally it is efficient.
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?
Without an output schema, the description should clarify what 'detailed information' includes (e.g., address, hours, coordinates) or behavioral traits. It also lacks differentiation from siblings and auth context, leaving operational gaps.
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 description coverage is 100%, with both location_id and access_token fully documented in the schema. The description adds no additional parameter semantics, but given the high schema coverage, the 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 verb ('Get'), resource ('detailed information about a specific location'), and scope ('by ID'). The 'by ID' phrasing implicitly distinguishes it from sibling search_locations_by_name and fetch_my_locations, though it does not explicitly name these alternatives.
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 siblings like search_locations_by_name (when the ID is unknown) or fetch_my_locations (for bulk retrieval). No prerequisites or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
review_analyzerC
Analyze reviews using the Obenan Review Analyzer API
| Name | Required | Description | Default |
|---|---|---|---|
| prompt | Yes | Question or prompt for the review analyzer |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure but fails to indicate if the operation is read-only, destructive, or idempotent. It does not disclose rate limits, authentication requirements, or what format the analysis results take.
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 sentence and appropriately concise, but suffers from under-specification rather than efficient information density. It is front-loaded with the verb and resource, yet wastes the opportunity to provide behavioral details within the same length.
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 single-parameter tool, the description is insufficient given the lack of output schema and annotations. It fails to explain what the Obenan Review Analyzer actually returns or the nature of the analysis performed, leaving critical gaps in the agent's understanding.
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 has 100% description coverage for the single 'prompt' parameter. The description adds no additional semantics about parameter format, expected content, or examples, meeting the baseline expectation when the schema is self-documenting.
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 identifies the resource (reviews) and action (analyze), but 'analyze' is vague regarding the specific analysis type (sentiment, summarization, extraction). It mentions the Obenan API, providing domain context that distinguishes it from location-focused siblings, though the core purpose remains under-specified.
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 provided on when to use this tool versus the location-based siblings (fetch_my_locations, etc.), nor any prerequisites, input constraints, or conditions for optimal use. The agent must infer applicability solely from the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_locations_by_nameB
Search for locations containing a specific name and allow selection to get details
| Name | Required | Description | Default |
|---|---|---|---|
| search_term | Yes | Term to search for in location names | |
| access_token | No | Access token for Obenan API. Optional if OBENAN_LOGIN_ACCESS_TOKEN environment variable is set. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure but fails to specify what the tool returns (list of locations? IDs only? how many results?), pagination behavior, search matching logic (partial, case-sensitive), or rate limits. The 'allow selection' phrase suggests interactive behavior but doesn't clarify the actual API mechanics.
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 brief (11 words) and front-loads the primary action, but the second clause 'and allow selection to get details' is structurally awkward and semantically vague. It attempts to pack workflow guidance into a single sentence, resulting in confusing phrasing that could be interpreted as the tool having interactive UI capabilities.
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 2-parameter search tool without output schema, the description covers the minimum viable use case but leaves significant gaps. It doesn't describe the return format (critical since no output schema exists), result limits, or the relationship to fetch_my_locations. Adequate but clearly incomplete given the lack of structured metadata.
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?
With 100% schema description coverage, the schema adequately documents both search_term and access_token without requiring additional description text. The description mentions no parameters explicitly, but the schema compensates fully, meeting the baseline expectation for this dimension.
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 core action ('Search for locations') and filtering criteria ('containing a specific name'). However, the phrase 'allow selection to get details' is ambiguous—it's unclear if the tool performs selection or merely returns candidates for selection via the sibling get_location_details tool.
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 implies a workflow (search → get details) but doesn't explicitly state when to use this tool versus fetch_my_locations. It hints at using results with get_location_details via 'allow selection to get details,' but lacks explicit 'when to use/when not to use' guidance or clear differentiation from the sibling that fetches 'my locations'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool has a clearly distinct purpose with no overlap: fetch_my_locations retrieves all locations, get_location_details provides details for a specific location, review_analyzer analyzes reviews, and search_locations_by_name searches by name. The descriptions clearly differentiate these functions, making tool selection unambiguous.
The naming is mostly consistent with a verb_noun pattern (fetch_my_locations, get_location_details, search_locations_by_name), but review_analyzer deviates slightly by using a noun_verb structure. This minor inconsistency does not significantly impact readability or predictability.
With 4 tools, this server is well-scoped for managing locations and reviews. Each tool serves a distinct and necessary function, and the count is appropriate for the domain without being too sparse or bloated.
The toolset covers core operations for location management (fetch, get details, search) and review analysis, but there are minor gaps such as missing CRUD operations for locations (e.g., create, update, delete) and reviews. However, agents can work effectively with the provided tools for basic workflows.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Google Keep-style notes app with an MCP server for AI agents to read/write notes.
Cross-session, cross-device memory for your agent: remember and recall notes. No key to start.
Markdown-based note-taking with a hosted MCP server. Your notes serve you and your AI.
Persistent memory layer for AI tools. Save and recall notes across Claude and other MCP clients.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceFacilitates note storage and summarization through custom URIs, allowing users to manage, summarize, and update notes with varying detail levels in a collaborative environment.
- FlicenseCqualityDmaintenanceThis server provides a note storage system with a custom URI scheme, allowing users to add and summarize notes, with adjustable summary detail levels.1
- FlicenseCqualityDmaintenanceThis server enables users to store, manage, and summarize notes using a custom URI scheme, with functionality to add new notes and generate summaries with varying levels of detail.3
- FlicenseCqualityNot gradedmaintenanceEnables creating and managing text notes with a simple note-taking system. Provides tools to create notes, access them via URIs, and generate summaries of all stored notes.41
Appeared in Searches
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Azhar-obenan/review-analyzer-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server