booklore-mcp
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., "@booklore-mcpWhat am I currently reading?"
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.
booklore-mcp
A Model Context Protocol (MCP) server for BookLore — your self-hosted digital library manager.
Connect Claude (or any MCP-compatible AI client) directly to your BookLore instance to search your library, check reading progress, update statuses and ratings, browse series, explore highlights, and more — all through natural conversation.
Requirements
BookLore v2.x running and accessible
Node.js 22+
An MCP-compatible client (Claude Desktop, Cursor, etc.)
Related MCP server: calibre-mcp
Installation
From GitHub Packages (recommended)
Add the scope registry to your project's
.npmrc(or~/.npmrc):@cyberglitchlabs:registry=https://npm.pkg.github.comAuthenticate with a GitHub personal access token that has
read:packagesscope://npm.pkg.github.com/:_authToken=YOUR_GITHUB_TOKENInstall the package:
npm install -g @cyberglitchlabs/booklore-mcp
From source
git clone https://github.com/cyberglitchlabs/booklore-mcp.git
cd booklore-mcp
npm install
npm run buildConfiguration
BookLore MCP supports two authentication methods.
Option A — API token (recommended if available)
Log in to your BookLore instance
Go to Settings → Profile
Copy your API token
Option B — Username / password
If you don't have easy access to an API token, you can authenticate with your BookLore username and password. The server will log in on startup, cache the access token, and automatically refresh it when it expires.
Environment variables
Variable | Required | Default | Description |
| ❌ |
| Base URL of your BookLore instance |
| ✅ (Option A) | — | Your BookLore API token |
| ✅ (Option B) | — | BookLore username |
| ✅ (Option B) | — | BookLore password |
Set either BOOKLORE_TOKEN or BOOKLORE_USERNAME + BOOKLORE_PASSWORD — not both.
Claude Desktop setup
Add the following to your Claude Desktop configuration file:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json
If installed via npm
Option A — API token:
{
"mcpServers": {
"booklore": {
"command": "booklore-mcp",
"env": {
"BOOKLORE_TOKEN": "your-token-here",
"BOOKLORE_BASE_URL": "http://localhost:6060"
}
}
}
}Option B — Username / password:
{
"mcpServers": {
"booklore": {
"command": "booklore-mcp",
"env": {
"BOOKLORE_USERNAME": "your-username",
"BOOKLORE_PASSWORD": "your-password",
"BOOKLORE_BASE_URL": "http://localhost:6060"
}
}
}
}If installed from source
Replace "command": "booklore-mcp" with:
"command": "node",
"args": ["/absolute/path/to/booklore-mcp/dist/index.js"]Restart Claude Desktop after saving.
Available tools
Books
Tool | Description |
| Search and filter books by title, author, library, shelf, status, rating, language, and file type |
| Full book details — metadata, progress, files, shelves, Goodreads rating |
| Set personal rating (1–5) |
| Set read status ( |
| Books currently in progress |
| Most recently added books |
Libraries
Tool | Description |
| List all libraries with book counts and allowed formats |
| Browse books in a specific library |
Shelves
Tool | Description |
| List all user-created shelves |
| List all smart/auto-populated shelves |
| Browse books on a specific magic shelf |
Series
Tool | Description |
| List or search series with reading progress |
| Get all books in a specific series |
Authors
Tool | Description |
| List or search authors |
| Author bio and book count |
| All books by a specific author |
Notebooks
Tool | Description |
| Books that have highlights or notes |
| All highlights and notes for a specific book |
Usage examples
"What books am I currently reading?"
"Search for sci-fi books I haven't read yet, sorted by most recently added"
"Show me all books in the Dune series"
"What are my highlights from Project Hail Mary?"
"Mark book 42 as read and give it a 5-star rating"
"List all my libraries"
Development
# Run in watch mode (auto-recompile on change)
npm run dev
# Type-check without emitting
npx tsc --noEmit
# Build for production
npm run build
# Run tests
npm test
# Lint
npm run lintDisclaimer
BookLore's API is internal and unversioned — it may change between BookLore releases without notice. This MCP server targets BookLore v2.x. If your BookLore instance is updated and tools start failing, check whether the API endpoints or response shapes have changed.
License
MIT
Available Tools
7 toolsget_bookA
Get full details for a specific book by its ID, including metadata, reading progress, file information, shelves, and notebook statistics.
| Name | Required | Description | Default |
|---|---|---|---|
| bookId | Yes | The BookLore book ID |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It lists the specific categories of data returned, adding value beyond the tool name. It does not explicitly state it is read-only, but the verb 'get' implies it, and no side effects or error behavior are mentioned, preventing a higher score.
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, front-loaded with the main action, and efficiently lists the included content. Every word earns its place.
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 simple get-by-ID tool with one parameter and no output schema, the description covers the key return categories. It could mention response format or error cases, but the low complexity and clear content list make it adequately complete.
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 already fully describes bookId (integer, BookLore book ID) with 100% coverage. The description only refers to 'its ID' without adding extra semantics, so it stays at the baseline.
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 retrieves full details for a specific book by ID, with a specific verb and resource. It enumerates the content (metadata, reading progress, file information, shelves, notebook statistics), distinguishing it from siblings like search_books or update_book_rating.
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: use when you need full details for a book given its ID. However, it does not explicitly mention alternatives or when not to use it, so it falls short of a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_continue_readingB
Get books that are currently in progress / ready to continue reading.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of books to return |
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 disclosing behavioral traits. It does not explain what defines 'in progress' (e.g., percentage read, last accessed), whether results are ordered, or if any state changes occur. This lack of context is a significant gap for a tool without annotations.
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 fluff. It efficiently conveys the tool's purpose without unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one documented parameter and no output schema, but the description leaves ambiguity about what 'in progress' means and the ordering/return format. While complete enough for basic understanding, it does not fully clarify the tool's behavior in edge cases or list semantics.
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 already fully documents the 'limit' parameter with a clear description, default, and bounds. The tool description adds no additional semantic value beyond what the schema provides, so 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 tool retrieves books that are in progress or ready for continued reading, using a specific verb ('get') and resource ('books'). However, it does not explicitly differentiate from sibling tools like search_books or get_recently_added, so it falls short of a 5.
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 phrase 'currently in progress / ready to continue reading' implies a usage context (when the user wants to resume books), but there is no explicit guidance on when to prefer this tool over alternatives like search_books or get_recently_added. No exclusions or alternative tool mentions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_recently_addedA
Get the most recently added books across all libraries.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of books to return |
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 of behavioral disclosure. It adds the 'across all libraries' scope, which is useful context beyond the name. However, it does not disclose the return format, ordering behavior (beyond 'most recently added'), or the effect of the limit parameter, which are relevant for an agent invoking the tool.
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, focused sentence that communicates the tool's purpose without any filler. It is front-loaded and every word contributes to understanding the 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?
The tool is relatively simple with one parameter and no output schema, but the description does not explain what the return value looks like (e.g., list of book objects, fields included). With no output schema, the description should have provided a bit more detail about the response structure or ordering to be fully complete for an agent.
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% (the 'limit' parameter is fully described with type, default, min, and max). Thus, the description adds no parameter-level information, and the baseline score of 3 applies. The description also does not contradict or expand on the schema.
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 function: retrieving the most recently added books across all libraries. It uses a specific verb ('get') and resource ('books'), and the 'across all libraries' scope distinguishes it from sibling tools like search_books or get_book. This leaves no ambiguity about the tool's purpose.
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 clear use case (obtaining recently added books without filtering), but it does not explicitly mention when to use this tool over alternatives or any exclusions. Sibling tools like search_books are not referenced, leaving the agent to infer the appropriate context from the name and description alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_booksB
Search and filter books in your BookLore library. Supports full-text search, filtering by library, shelf, series, author, language, file type, rating, and read status. Returns paginated results.
| Name | Required | Description | Default |
|---|---|---|---|
| dir | No | Sort direction: asc or desc | |
| page | No | Page number (0-indexed) | |
| size | No | Page size (1–100) | |
| sort | No | Sort field: title, addedOn, lastReadTime, or personalRating | |
| search | No | Full-text search across title, author, and description | |
| status | No | Filter by read status: WANT_TO_READ, IN_PROGRESS, READ, or DNF | |
| authors | No | Filter by author name (comma-separated for multiple) | |
| shelfId | No | Filter by shelf ID | |
| fileType | No | Filter by file type: EPUB, PDF, CBZ, CBR, CB7, MOBI, AZW3, MP3, M4B, M4A, or AUDIOBOOK | |
| language | No | Filter by language code (e.g. 'en', 'fr') | |
| libraryId | No | Filter by library ID | |
| maxRating | No | Maximum personal rating (1–5) | |
| minRating | No | Minimum personal rating (1–5) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the transparency burden. It discloses pagination ('Returns paginated results') but falsely claims support for filtering by 'series'—no such parameter exists in the schema. This misleading statement reduces trust and transparency.
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 two concise sentences. It front-loads the primary purpose and lists capabilities, with no unnecessary fluff. Despite the inaccuracy, the structure 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?
Given 13 optional parameters and no output schema, the description is too sparse. It does not explain how filters combine, default sort/pagination, or what the return payload looks like. The false 'series' claim further undermines 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?
Schema description coverage is 100%, setting a baseline of 3, but the description adds no meaningful per-parameter detail beyond what the schema already provides. Worse, it mentions a nonexistent 'series' filter, which could mislead agents into attempting an invalid parameter. This inaccurate addition lowers the score.
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 starts with 'Search and filter books in your BookLore library,' identifying the specific verb and resource. It distinguishes this from sibling tools like get_book and update_book_rating by focusing on search/filter rather than single-item operations.
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 use for broad search and filtering tasks, which is clear from context. However, it does not explicitly state when to prefer this over alternatives or provide exclusions, so it stops at 'clear context, no exclusions' level.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
update_book_ratingA
Set a personal rating for a book (1–5 stars).
| Name | Required | Description | Default |
|---|---|---|---|
| bookId | Yes | The BookLore book ID | |
| rating | Yes | Rating from 1 (lowest) to 5 (highest) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description must carry the full burden of behavioral disclosure. It only states the core action and rating range, and does not clarify whether the rating overwrites an existing rating, requires authentication, or has side effects. This is a significant gap for a mutation tool.
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?
One short, front-loaded sentence with no wasted words. It directly states the verb, object, and rating scale, making it highly 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?
For a simple two-parameter mutation with no output schema, the description and schema provide enough to select and invoke the tool correctly. It covers the essential purpose and parameters, though it omits behavioral nuances like overwrite semantics.
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 parameters already clearly described (bookId and rating with bounds). The description adds no additional parameter meaning beyond echoing the rating range, so a baseline of 3 applies.
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 action ('Set') and the resource ('a personal rating for a book') with the rating range (1–5 stars). It distinguishes itself from sibling update_book_status by focusing on the personal rating rather than book status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The usage context is implied: use this tool when you want to assign a personal rating to a book. However, it does not explicitly mention alternatives or when not to use it, relying on the name and sibling names to convey differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
update_book_statusC
Update the read status of a book.
| Name | Required | Description | Default |
|---|---|---|---|
| bookId | Yes | The BookLore book ID | |
| status | Yes | Read status: WANT_TO_READ, IN_PROGRESS, READ, or DNF (Did Not Finish) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden for behavioral disclosure. It only says 'update', implying a mutation, but does not state whether the operation is idempotent, whether it overwrites the previous status, or what side effects or response to expect. This is minimal and leaves significant ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no wasted words. It is front-loaded with the core purpose, but could have included more useful context without being verbose, hence not a 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has a simple two-parameter schema with no output schema and no annotations, but the description still fails to provide essential context such as usage, side effects, or relationship to other tools. It is bare-bones and not complete enough for an agent to fully understand the tool's behavior.
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%, as both 'bookId' and 'status' have detailed descriptions in the input schema. The tool description adds no additional meaning beyond those schema descriptions, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Update') and a resource ('read status of a book'), which distinguishes it from the sibling 'update_book_rating'. However, it does not elaborate on what statuses exist or any nuance, so it is not a 5.
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 gives no guidance on when to use this tool versus alternatives like 'update_book_rating' or 'get_book'. It does not mention any prerequisites or typical scenarios, leaving the agent without context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
use_booklore_categoryA
Enable or disable a BookLore tool category to manage context usage. Call this to activate a category before using its tools. Categories: books (default: enabled), libraries, shelves, series, authors, notebooks. After enabling, re-check your available tools on the next request.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | ||
| category | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosure. It reveals that the tool toggles categories, affects tool availability, and that changes apply on the next request. This is useful behavioral context. It could be more explicit about side effects (e.g., whether disabling removes tools from the current context), but the description covers the key behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three concise sentences, front-loaded with the primary action. It includes all necessary information without any fluff or redundancy, making it easy to scan and understand.
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 simple toggle tool, the description is fairly complete. It explains how to use it, the categories, and that tools become available on the next request. It does not explain return values, but the output schema is absent and the tool's effect on tool availability is more important. Slight gaps include no mention of error cases or reversibility, but these are minor.
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 0%, but the description compensates by explaining 'Enable or disable' (mapping to the action parameter) and listing all category values, including the default state for books. It adds meaning beyond the enum literals by indicating the purpose of each parameter. More detail on what each category contains would be helpful, but the sibling tool names provide some hints.
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: 'Enable or disable a BookLore tool category' with a specific verb and resource. It also lists the available categories and distinguishes itself from sibling tools that perform book operations, making its role as a meta-tool unmistakable.
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 gives explicit usage context: 'Call this to activate a category before using its tools' and advises re-checking available tools after enabling. It also notes that books is enabled by default, which helps with when to use the tool. However, it does not explicitly mention when not to use it or alternative approaches, though the intent is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool serves a clearly distinct purpose: search, retrieve details, update rating/status, and get specific book lists. The meta-tool for category management is separate from book operations, eliminating any overlap.
Most tools follow a verb_noun pattern in snake_case (search_books, get_book, update_book_rating). 'use_booklore_category' deviates slightly from the update/get/search verbs, but the pattern remains readable and consistent overall.
Seven tools is well-scoped for a personal library assistant. Each tool addresses a core need—searching, viewing, updating, and tracking—without unnecessary redundancy or gaps.
The core book lifecycle is covered: search, details, rating, status, and reading progress. Missing create/delete operations are likely out of scope, and the category system hints at additional modules, so coverage is strong for the stated purpose.
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
AI assistant integration for Leaf — track books, log reading sessions, and manage your library.
The media memory layer for AI agents and their humans. Your AI client gets 29 tools to search your collection, add items, update ratings, preview music, and find patterns across everything you've read, watched, and listened to.
Academic literature search, retrieval, and private library management on top of OpenAlex.
Media memory for AI agents and their humans: books, movies, music, shows, anime, podcasts, games.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables AI assistants to help users manage their reading experience by searching books, tracking reading progress, managing bookmarks, and generating personalized recommendations and summaries.
- AlicenseNot gradedqualityDmaintenanceEnables searching, reading, and managing a Calibre ebook library through natural language, with features like metadata search, full-text search, content extraction, and library management.221Apache 2.0
- AlicenseAqualityAmaintenanceConnects AI assistants to the Hardcover book library, enabling natural language book searches, reading status updates, list management, and library exploration.315MIT
- AlicenseNot gradedqualityCmaintenanceProvides AI assistants with direct access to your ebook library, enabling listing books, reading chapters, and searching across books via the Model Context Protocol.MIT
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/cyberglitchlabs/booklore-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server