Personal MCP

by itsjustayush

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation3/5
Each getter targets a distinct data category, but get_context overlaps with all of them by accepting the same topics, and search_personal_data can also duplicate broad retrieval. Descriptions help, but an agent may hesitate between the generic and specific tools.
Naming Consistency4/5
The vast majority follow a clear get_<resource> pattern (get_profile, get_education, get_projects). search_personal_data is a minor deviation, but it still uses a predictable verb_noun structure, so the set remains consistent.
Tool Count5/5
Eight tools is well-scoped for a personal-data retrieval server. Each resource area is represented without excessive fragmentation or unnecessary bulk.
Completeness5/5
The surface covers all advertised personal data categories (profile, education, experience, skills, projects), plus a search tool and a generic context tool that can return everything. For a read-only personal information server, there are no obvious dead ends.
Average 3.3/5 across 8 of 8 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 3 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of explaining behavior. It states a read-like action but does not explicitly confirm that it has no side effects, mention ordering, pagination beyond the limit, or any other behavioral traits an agent would need to anticipate.
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?
The description is a single compact sentence that communicates the core action and the optional parameter behavior without wasted words. It could not be meaningfully shorter while retaining content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is too sparse for a tool that has a closely related sibling (get_project) and an output schema that should clarify return shape. It fails to explain the distinction between the plural and singular project tools, leaving an agent without enough context to choose correctly.
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 schema provides only the type and default for 'limit' with no description, so the description adds some value by linking it to limiting the number of items. However, 'items' is vague and does not clarify whether it refers to projects, nested project elements, or something else.
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 action ('Return') and the resource ('project information'), so the basic purpose is understandable. However, it does not differentiate from the closely named sibling tool get_project, leaving ambiguity about whether this returns a list of projects or a single project.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use get_projects versus get_project or any other sibling tool. The phrase 'optionally limiting the number of items' hints at list behavior, but there is no explicit context or exclusion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description is only 'Return skills information.' It conveys a read operation but does not disclose any behavioral details such as whether results are aggregated, sorted, filtered, or require authentication. With no annotations, the description carries the burden and falls short.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence with no filler, so it is readable and front-loaded. However, it is underspecified and the content largely paraphrases the tool name, so it does not add much meaningful information.
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?
For a zero-parameter read-only getter with an output schema, the description states the basic purpose adequately. It is not complete, though, because it gives no guidance on selection among sibling getters and no real behavioral context beyond the name.
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?
The input schema is empty with 100% coverage, so there are no parameter semantics for the description to explain. With zero parameters, the baseline of 4 applies, and the description's reference to 'skills information' is sufficient.
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 a verb ('Return') and a resource ('skills information'), so an agent can identify what the tool accesses. However, it is close to restating the tool name and offers no distinguishing details about the kind of skills data returned or how it differs from sibling getters.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no statement about when to call this tool versus siblings like get_context, get_profile, or search_personal_data. The agent is left to infer the appropriate selection from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. The verb 'Return' implies a read operation with no side effects, but it provides no additional behavioral context such as data source, permission requirements, or what exactly is included in 'education information'. The description stays at the surface level.
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?
The description is a single, short sentence with no redundant words. It is appropriately sized for a parameterless read tool, though it lacks the richer detail that could still be conveyed compactly.
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 simple with zero parameters and an output schema present, so the description need not explain return values. However, the description gives no context about when to use this tool relative to sibling profile getters, making the overall guidance feel incomplete for an agent that needs to disambiguate similar tools.
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?
The tool has zero parameters, so the description is not required to add parameter-level meaning. The schema already covers the empty parameter contract completely, and there is nothing further to explain.
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 a clear verb ('Return') and resource ('education information'), making the tool's basic purpose unambiguous. However, it does not differentiate this from sibling getters like get_context or get_skills, which share a similar structure and could be confused when an agent is choosing among profile section retrievers.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus its siblings. The description merely restates the function name without specifying contexts, exclusions, or alternatives, leaving the agent to infer usage 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.
Behavior2/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 of behavioral disclosure. It only says 'Return relevant information,' which implies a read operation, but it does not describe aggregation behavior, error handling for invalid topics, permissions, or any side effects.
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?
A single sentence that front-loads the action and immediately lists the acceptable topics. There is no filler, and every word contributes to understanding the tool's purpose.
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 simple, has one required parameter, and an output schema exists, so basic invocation is covered. However, the absence of sibling differentiation and behavioral details leaves an agent uncertain about when to choose get_context over the individual getters or what happens with an unsupported topic.
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?
The input schema only defines topic as a string with 0% description coverage. The description compensates by listing valid values: 'profile, projects, education, experience, skills, or all.' This adds meaningful semantics beyond the raw schema, though it omits the singular 'project' and does not formally declare an enum.
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 uses a specific verb ('Return') and names the resource ('relevant information for a given topic'), then enumerates the accepted topics. It is clear enough to understand what the tool does, though it does not explicitly contrast itself with the sibling get_* tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus the individual sibling tools like get_profile, get_education, or get_experience. The phrase 'or all' hints at aggregation, but the description never states when a caller should prefer get_context over the more specific tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of behavioral disclosure. It does disclose a key behavior: case-insensitive, simple matching. However, it does not say whether matching applies to all fields, whether it is substring or token-based, or whether the operation is read-only, leaving some ambiguity.
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?
The description is a single sentence with no fluff. It front-loads the core action and resource, then adds the distinguishing behavior. Every word contributes meaningful information.
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 low complexity with one parameter and an output schema, which lowers the burden. The description covers the basic purpose and matching behavior. Still, it lacks usage guidance relative to sibling get_* tools and does not clarify what 'personal data' covers, leaving some gaps for an agent deciding between tools.
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 0%, so the description must compensate. It adds the meaning that the query parameter is matched case-insensitively and simply. However, it does not define the matching scope or format beyond that, leaving partial ambiguity for the single query parameter.
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 uses a specific verb ('Search'), identifies the resource ('personal data JSON files'), and adds matching behavior ('simple case-insensitive matching'). It is clearly distinct from the sibling get_* tools by the nature of search versus retrieval, though it does not explicitly name a sibling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool versus the get_* alternatives. It does not state exclusions, prerequisites, or conditions such as 'use when you need to filter across sections rather than retrieve a specific field.' The usage context is only loosely implied by the word 'search.'
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description is the only source of behavioral information. 'Return' accurately implies a read operation, but the description does not explicitly disclose read-only status, potential side effects, data source, or output characteristics other than 'information.' For a zero-parameter getter this is minimally adequate but not rich.
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?
The description is a single, front-loaded sentence with no filler words. It communicates the essential purpose efficiently and is appropriately sized for a no-argument getter.
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?
For a zero-parameter tool with an output schema, the description is largely sufficient to invoke it: no arguments are needed and return shape is presumably covered by the output schema. It could be more complete by clarifying the boundary between 'work and experience' and the related sibling tools, but that is not critical for making a valid call.
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?
The tool has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics; the input schema is trivially complete.
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 action ('Return') and the resource ('work and experience information'), so an agent can understand the tool's basic purpose. However, it does not explicitly contrast this with sibling tools like get_education, get_skills, or get_projects, leaving some differentiation to inference.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to choose this tool over the available sibling tools. There is no mention of context, exclusions, or alternatives, so an agent must rely entirely on the tool name to infer appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The word 'Return' implies a read-only operation, which is useful given no annotations are provided. However, the description adds no further behavioral context such as authentication requirements, whether the profile is the current user's only, or how the response is structured beyond what the output schema may provide.
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?
The description is a single sentence with no wasted words. It front-loads the action and resource, making it immediately scannable.
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?
For a zero-parameter tool with an output schema, the description is nearly complete. A brief note on when to use the aggregate profile rather than the sectional sibling tools would improve it, but no critical calling information is missing.
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?
The tool has zero parameters, so there is nothing for the description to clarify. The schema is empty with 100% coverage, making parameter ambiguity impossible.
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 a clear action and resource: 'Return the user's profile information.' It is not a tautology and is understandable, but it does not explicitly distinguish the full profile from sibling endpoints like get_education or get_experience.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to call get_profile versus the sibling tools. The distinction from get_context or get_education is only implied by the tool names and sibling list, not stated in the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral transparency burden. It discloses the case-insensitive matching behavior, which is genuinely useful, but it does not mention what happens when the project is not found, permission requirements, or whether this is strictly 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no filler, front-loads the core action and resource, and every word adds meaning. This is an appropriately sized and well-structured definition.
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?
For a simple one-parameter tool with an output schema, the description covers the essential behavior: return one project, case-insensitive by name. Some edge-case context, such as not-found behavior, would improve it, but the simplicity of the tool limits the impact of that gap.
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 schema has 0% coverage, leaving the 'name' parameter with only a title. The description compensates partially by indicating that matching is case-insensitive, but it does not explain the expected name format or whether partial names are acceptable.
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?
The description states a specific verb ('Return'), a precise resource ('a single project'), and a distinguishing scope ('single' vs. get_projects). It also adds a useful semantic detail ('case-insensitive') that makes the tool's purpose unambiguous.
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 this tool is for retrieving one project by name, and 'single' suggests when not to use the plural sibling get_projects. However, it does not explicitly state when to prefer this over alternatives like get_projects or search_personal_data.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![meteorbase-mcp MCP server](https://glama.ai/mcp/servers/itsjustayush/meteorbase-mcp/badges/card.svg)](https://glama.ai/mcp/servers/itsjustayush/meteorbase-mcp)

Score Badge

Copy to your README.md:

[![meteorbase-mcp MCP server](https://glama.ai/mcp/servers/itsjustayush/meteorbase-mcp/badges/score.svg)](https://glama.ai/mcp/servers/itsjustayush/meteorbase-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/itsjustayush/meteorbase-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server