Limitless MCP Server
Allows pulling action items from Limitless Pendant Lifelogs and sending them directly into Notion.
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., "@Limitless MCP Servershow my recordings from yesterday"
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.
Limitless MCP Server (v0.1.0)
This is an MCP (Model Context Protocol) server that connects your Limitless Pendant data to AI tools like Claude, Windsurf, and others via the Limitless API. It lets AI chat interfaces and agents interact with your Lifelog in a structured, programmable way. Let’s build towards a more organized, intelligent future—one context-rich interaction at a time.
What’s MCP?
Model Context Protocol is an open standard for connecting AI models to external tools and data—think of it like the USB-C port or even the HTTP protocol for AI—universal, reliable, and designed for extensibility. The standard that everyone adopts. It enables rich integrations, custom workflows, and seamless communication between AI and the tools you use every day.
IMPORTANT NOTE: As of March 2025, the Limitless API requires data recorded via the Limitless Pendant. This server depends on real data recorded from your Limitless Pendant—it won’t return anything meaningful without it. Ensure your Pendant is connected and recording.
API Status & Future Plans:
The official Limitless API is currently in beta. As such, it may occasionally be unreliable, subject to change, or experience temporary outages.
Requesting large amounts of data (e.g., listing or searching hundreds of logs) may sometimes result in timeout errors (like 504 Gateway Time-out) due to API or network constraints. The server includes a 120-second timeout per API call to mitigate this, but very large requests might still fail.
The Limitless API is under active development. This MCP server will be updated with new features and improvements as they become available in the official API.
Version 0.2.0 of this MCP server is already under development, with plans to add more robust features and potentially new tools in the near future!
Features (v0.1.0)
List/Get Lifelogs: Retrieve Pendant recordings by ID, date, date range, or list recent entries. Includes control over sort direction (
asc/desc).Search Recent Logs: Perform simple text searches within the content of a configurable number of recent Pendant recordings (Note: only recent logs are searchable; full-history search is not supported).
With this server, you can do things like pull action items from your Lifelog and send them directly into Notion—via Claude, ChatWise, Windsurf, or any other AI assistant/app that supports MCP.
Related MCP server: BeeMCP
Prerequisites
Node.js (v18 or later required)
npm or yarn
A Limitless account and API key (Get one here)
A Limitless Pendant (Required for data)
An MCP Client application (e.g., Claude, Windsurf, Cursor, ChatWise, ChatGPT (coming soon!)) capable of spawning stdio servers and passing environment variables.
Setup
Clone or download this project.
Navigate to the directory:
cd mcp-limitless-serverInstall dependencies:
npm installBuild the code:
npm run build
Configuration (Client-Side)
This server expects the LIMITLESS_API_KEY to be provided as an environment variable when it is launched by your MCP client.
You need to add a server configuration block to your MCP client's settings file. Below are two examples depending on whether you are adding this as your first server or adding it alongside existing servers.
Example A: Adding as the first/only server
If your client's configuration file currently has an empty mcpServers object ("mcpServers": {}), replace it with this:
{
"mcpServers": {
"limitless": {
"command": "node",
"args": ["<FULL_FILE_PATH_TO_DIST_SERVER.js>"],
"env": {
"LIMITLESS_API_KEY": "<YOUR_LIMITLESS_API_KEY_HERE>"
}
}
}
}Example B: Adding to existing servers
If your mcpServers object already contains other servers (like "notion": {...}), add the "limitless" block alongside them, ensuring correct JSON syntax (commas between entries):
{
"mcpServers": {
"some_other_server": {
"command": "...",
"args": ["..."],
"env": {
"EXAMPLE_VAR": "value"
}
},
"limitless": {
"command": "node",
"args": ["<FULL_FILE_PATH_TO_DIST_SERVER.js>"],
"env": {
"LIMITLESS_API_KEY": "<YOUR_LIMITLESS_API_KEY_HERE>"
}
}
}
}Important:
Replace
<FULL_FILE_PATH_TO_DIST_SERVER.js>with the correct, absolute path to the built server script (e.g.,/Users/yourname/Documents/MCP/mcp-limitless-server/dist/server.js). Relative paths might not work reliably depending on the client.Replace
<YOUR_LIMITLESS_API_KEY_HERE>with your actual Limitless API key.MCP config files cannot contain comments. Remove any placeholder text like
<YOUR_LIMITLESS_API_KEY_HERE>and replace it with your actual key.
Running the Server (via Client)
Do not run npm start directly.
Ensure the server is built successfully (
npm run build).Configure your MCP client as shown above.
Start your MCP client application. It will launch the
mcp-limitless-serverprocess automatically when needed.
Exposed MCP Tools (v0.1.0)
(Refer to src/server.ts or ask the server via your client for full details.)
limitless_get_lifelog_by_id: Retrieves a single Pendant recording by its specific ID.limitless_list_lifelogs_by_date: Lists Pendant recordings for a specific date.limitless_list_lifelogs_by_range: Lists Pendant recordings within a date/time range.limitless_list_recent_lifelogs: Lists the most recent Pendant recordings.limitless_search_lifelogs: Searches title/content of recent Pendant recordings (limited scope!).
Notes & Limitations
🚫 Pendant Required
This server depends on data generated by the Limitless Pendant.
🧪 API Beta Status
The Limitless API is in beta and may experience occasional instability or rate limiting. Large requests might result in timeouts (e.g., 504 errors).
🔍 Search Scopelimitless_search_lifelogs only scans a limited number of recent logs (default 20, max 100). It does not search your full history — use listing tools first for broader analysis.
⚠️ Error Handling & Timeout
API errors are translated into MCP error results. Each API call has a 120-second timeout.
🔌 Transport
This server uses stdio and is meant to be launched by an MCP-compatible client app.
Contributing
Have ideas, improvements, or feedback? Feel free to open an issue or PR—contributions are always welcome! Let’s keep pushing the boundaries of what’s possible with wearable context and intelligent tools. https://github.com/ipvr9/mcp-limitless-server
Available Tools
5 toolslimitless_get_lifelog_by_idC
Retrieves a single lifelog or Pendant recording by its specific ID.
| Name | Required | Description | Default |
|---|---|---|---|
| lifelog_id | Yes | The unique identifier of the lifelog to retrieve. | |
| includeMarkdown | No | Include markdown content in the response. | |
| includeHeadings | No | Include headings content in the response. |
TDQS
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 states it 'retrieves' data, implying a read-only operation, but doesn't disclose behavioral traits like authentication needs, rate limits, error handling, or what happens if the ID is invalid. This is a significant gap for a tool with no annotation coverage.
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, efficient sentence with zero waste. It's front-loaded with the core purpose and appropriately sized for a simple retrieval tool.
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 no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., lifelog details, format), error conditions, or prerequisites. For a retrieval tool with three parameters, this leaves the agent with insufficient context.
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%, so the schema fully documents all parameters. The description adds no additional meaning beyond what the schema provides, such as explaining the purpose of 'includeMarkdown' or 'includeHeadings' in context. Baseline 3 is appropriate when the schema does the heavy lifting.
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 ('retrieves') and resource ('a single lifelog or Pendant recording'), making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'limitless_list_lifelogs_by_date' or 'limitless_search_lifelogs', which also retrieve lifelogs but with different filtering mechanisms.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention that this is for retrieving a specific lifelog by ID, whereas siblings retrieve lists or search results, leaving the agent to infer usage 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.
limitless_list_lifelogs_by_dateB
Lists logs/recordings for a specific date. Best for getting raw log data which you can then analyze for summaries, action items, topics, etc.
| Name | Required | Description | Default |
|---|---|---|---|
| date | Yes | The date to retrieve lifelogs for, in YYYY-MM-DD format. | |
| limit | No | Maximum number of lifelogs to return (Max: 100). Fetches in batches from the API if needed. | |
| timezone | No | IANA timezone for date/time parameters (defaults to server's local timezone). | |
| includeMarkdown | No | Include markdown content in the response. | |
| includeHeadings | No | Include headings content in the response. | |
| direction | No | Sort order ('asc' for oldest first, 'desc' for newest first). |
TDQS
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 mentions the tool is for 'getting raw log data' and analysis, but doesn't disclose behavioral traits like whether it's read-only, has rate limits, authentication needs, or what the response format looks like. The description adds minimal context beyond the basic purpose.
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 concise and front-loaded with the core purpose in the first sentence. The second sentence adds useful context about usage. Both sentences earn their place, though it could be slightly more structured (e.g., explicitly mentioning sibling tools).
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 no annotations and no output schema, the description is moderately complete for a list tool. It covers the purpose and usage context but lacks details on behavioral traits (e.g., pagination, error handling) and output format, which are important for a tool with 6 parameters and no structured output documentation.
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%, so the schema already documents all parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema, such as explaining how 'date' interacts with 'timezone' or the implications of 'includeMarkdown'. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Lists logs/recordings for a specific date.' It specifies the verb ('Lists') and resource ('logs/recordings'), but doesn't explicitly differentiate from siblings like 'limitless_list_lifelogs_by_range' or 'limitless_list_recent_lifelogs' beyond the date specificity.
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 some usage guidance: 'Best for getting raw log data which you can then analyze for summaries, action items, topics, etc.' This implies when to use it (for raw data analysis), but doesn't explicitly state when not to use it or name alternatives among the sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
limitless_list_lifelogs_by_rangeA
Lists logs/recordings within a date/time range. Best for getting raw log data which you can then analyze for summaries, action items, topics, etc.
| Name | Required | Description | Default |
|---|---|---|---|
| start | Yes | Start datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:mm:SS). | |
| end | Yes | End datetime filter (YYYY-MM-DD or YYYY-MM-DD HH:mm:SS). | |
| limit | No | Maximum number of lifelogs to return (Max: 100). Fetches in batches from the API if needed. | |
| timezone | No | IANA timezone for date/time parameters (defaults to server's local timezone). | |
| includeMarkdown | No | Include markdown content in the response. | |
| includeHeadings | No | Include headings content in the response. | |
| direction | No | Sort order ('asc' for oldest first, 'desc' for newest first). |
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. It mentions the tool is for listing raw log data, implying a read-only operation, but does not specify permissions, rate limits, or response format details. The description adds some context about data analysis use but lacks comprehensive behavioral traits like pagination or error handling.
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 front-loaded with the core purpose in the first sentence and adds a concise usage guideline in the second. Both sentences earn their place by providing clear value without redundancy, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, no output schema, no annotations), the description is moderately complete. It covers purpose and usage but lacks details on behavioral aspects like response format, error cases, or prerequisites. Without annotations or output schema, more context on what the tool returns would be beneficial for full completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already documents all 7 parameters thoroughly. The description does not add any parameter-specific semantics beyond what the schema provides, such as explaining interactions between parameters or default behaviors. Baseline 3 is appropriate as the schema handles parameter documentation adequately.
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 ('Lists') and resource ('logs/recordings') with specific scope ('within a date/time range'). It distinguishes from siblings by emphasizing raw log data for analysis, unlike tools like 'limitless_get_lifelog_by_id' (single log) or 'limitless_list_lifelogs_by_date' (date-specific).
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 clear context for when to use this tool ('Best for getting raw log data which you can then analyze for summaries, action items, topics, etc.'). However, it does not explicitly state when not to use it or name specific alternatives among the siblings, such as 'limitless_list_recent_lifelogs' for recent logs without date ranges.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
limitless_list_recent_lifelogsA
Lists the most recent logs/recordings (sorted newest first). Best for getting raw log data which you can then analyze for summaries, action items, topics, etc.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of recent lifelogs to retrieve (Max: 100). Defaults to 10. | |
| timezone | No | IANA timezone for date/time parameters (defaults to server's local timezone). | |
| includeMarkdown | No | Include markdown content in the response. | |
| includeHeadings | No | Include headings content in the response. |
TDQS
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 mentions sorting ('newest first') and the nature of the data ('raw log data'), which adds useful context. However, it lacks details on permissions, rate limits, pagination, or what the response format looks like (e.g., structure of returned logs). This leaves gaps for a tool with no annotation coverage.
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 concise and well-structured with two sentences: the first states the core functionality, and the second provides usage guidance. Every sentence adds value without redundancy, making it easy to parse and front-loaded with key information.
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 no annotations and no output schema, the description is moderately complete. It covers purpose and usage but lacks behavioral details (e.g., response format, error handling) and doesn't fully compensate for the absence of structured output information. For a list tool with 4 parameters, it's adequate but has clear gaps in transparency.
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%, so the schema fully documents all 4 parameters (limit, timezone, includeMarkdown, includeHeadings). The description doesn't add any parameter-specific information beyond what's in the schema, such as explaining how 'limit' interacts with 'recent' or the implications of the boolean flags. Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Lists the most recent logs/recordings (sorted newest first).' It specifies the verb ('lists'), resource ('logs/recordings'), and sorting behavior. However, it doesn't explicitly differentiate from siblings like 'limitless_list_lifelogs_by_date' or 'limitless_list_lifelogs_by_range' beyond mentioning 'recent' and 'newest first.'
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 clear usage context: 'Best for getting raw log data which you can then analyze for summaries, action items, topics, etc.' This implies when to use it (for raw data analysis) but doesn't explicitly state when not to use it or name alternatives among the sibling tools, such as when date-based filtering is needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
limitless_search_lifelogsA
Performs a simple text search for specific keywords/phrases within the title and content of recent logs/Pendant recordings. Use ONLY for keywords, NOT for concepts like 'action items' or 'summaries'. Searches only recent logs (limited scope).
| Name | Required | Description | Default |
|---|---|---|---|
| search_term | Yes | The text to search for within lifelog titles and content. | |
| fetch_limit | No | How many *recent* lifelogs to fetch from the API to search within (Default: 20, Max: 100). This defines the scope of the search, NOT the number of results returned. | |
| limit | No | Maximum number of lifelogs to return (Max: 100). Fetches in batches from the API if needed. | |
| timezone | No | IANA timezone for date/time parameters (defaults to server's local timezone). | |
| includeMarkdown | No | Include markdown content in the response. | |
| includeHeadings | No | Include headings content in the response. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses important behavioral traits: the search is limited to recent logs, it searches both title and content, and it's keyword-based (not conceptual). However, it doesn't mention authentication requirements, rate limits, error conditions, or what the response format looks like. For a search tool with 6 parameters, this leaves significant behavioral aspects undocumented.
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?
Three concise sentences with zero waste. Each sentence adds distinct value: first states the core function, second provides critical usage restrictions, third clarifies scope limitation. The description is appropriately sized and front-loaded with essential information.
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 search tool with 6 parameters and no output schema, the description provides good purpose and usage guidance but lacks behavioral details about authentication, rate limits, error handling, and response format. The absence of annotations means the description should compensate more for behavioral transparency, which it only partially addresses. It's adequate but has clear gaps for a tool of this complexity.
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%, so the schema already documents all parameters thoroughly. The description adds some context about 'recent' logs which relates to fetch_limit's scope, but doesn't provide additional parameter semantics beyond what's in the schema. This meets the baseline expectation when schema coverage is complete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('performs a simple text search') and resources ('within the title and content of *recent* logs/Pendant recordings'). It distinguishes from siblings by specifying it's for keyword searches only, unlike list/retrieve siblings like limitless_list_lifelogs_by_date or limitless_get_lifelog_by_id.
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?
Explicitly states when to use ('Use ONLY for keywords, NOT for concepts like 'action items' or 'summaries'') and provides context about scope ('Searches only recent logs (limited scope)'). This gives clear guidance on appropriate vs. inappropriate use cases, though it doesn't name specific alternative tools.
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. Dates show when Glama detected each change.
5 tool updates
v1.0.0- First observed
limitless_get_lifelog_by_id - First observed
limitless_list_lifelogs_by_date - First observed
limitless_list_lifelogs_by_range - First observed
limitless_list_recent_lifelogs - First observed
limitless_search_lifelogs
TDQS
The tools are mostly distinct in purpose, focusing on different retrieval methods for lifelogs. However, there is some overlap between 'list_lifelogs_by_date', 'list_lifelogs_by_range', and 'list_recent_lifelogs', as all three list logs based on time criteria, which could cause mild confusion about which to use for specific time-based queries.
All tool names follow a consistent pattern: they start with 'limitless_' followed by a verb_noun structure (e.g., 'get_lifelog_by_id', 'list_lifelogs_by_date'). This uniformity makes the tool set predictable and easy to navigate.
With 5 tools, the server is well-scoped for its purpose of retrieving lifelogs. Each tool serves a specific function (e.g., by ID, date, range, recency, search), and none seem redundant or missing for basic retrieval operations.
The tool set covers retrieval operations comprehensively, but there are notable gaps in the lifecycle. It lacks create, update, or delete tools for lifelogs, which limits agents to read-only interactions. This could cause failures if agents need to modify data.
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
- QuallaaOAuthcom.quallaa
Talk to your public-facing AI from any MCP client — Claude, ChatGPT, Cursor, Cline, Windsurf.
- MysocialOAuthio.mysocial
Social media MCP server: your Instagram, TikTok, YouTube, LinkedIn and Threads history for your AI.
1 - mcpOAuthai.butlerbrain
Persistent memory for AI assistants. Save once; recall from Claude, ChatGPT, or any MCP client.
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceMCP server that connects Whoop fitness data to Claude, enabling natural language queries about recovery, sleep, workouts, and more.-
- AlicenseNot gradedqualityDmaintenanceUnofficial MCP server that bridges AI assistants with Bee wearable lifelogging data, enabling retrieval and management of conversations, facts, todos, and locations.48MIT
- AlicenseNot gradedqualityDmaintenanceMCP server that exposes the Limitless Developer API to list lifelogs via the getLifelogs tool.14MIT
- AlicenseNot gradedqualityAmaintenanceMCP server that connects AI assistants like Claude to WHOOP health data, enabling natural language queries about recovery, sleep, workouts, and more.194149MIT
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/boyleryan/mcp-limitless-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server