Pine Assistant MCP Server

Official

by 19PINE-AI

Overview Schema Related Servers Score Discussions

Python

Remote

Server Quality Checklist

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

Latest release: v0.1.4
Disambiguation5/5
Each tool has a distinct purpose with clear boundaries. Authentication, session management, messaging, attachments, forms, location, tasks, and social sharing are all separated into specific tools, minimizing confusion.
Naming Consistency4/5
All tool names follow the 'pine_<descriptive_name>' pattern with underscores, but the order of verb and noun varies slightly (e.g., 'pine_auth_request_code' vs 'pine_session_create'). Still, the naming is consistent in style and readability.
Tool Count5/5
19 tools is well-scoped for a customer service automation assistant. Each tool covers a necessary function without redundancy or bloat, making the toolset manageable and focused.
Completeness4/5
The toolset covers the core lifecycle: session management, authentication, messaging, attachments, form responses, location handling, task control, and social sharing. Minor gaps exist such as no explicit tool for deleting call reminders or handling payments, but these can be worked around.
Average 3.8/5 across 19 of 19 tools scored. Lowest: 2.6/5.
See the Tool Scores section below for per-tool breakdowns.
- 1 of 1 community issues answered or closed in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is failing
This repository is licensed under MIT License.
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, the description must disclose behavioral traits. It only states 'Submit a location selection' with no mention of side effects, confirmation, error handling, or return behavior. This is insufficient 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short but includes an 'Args' section that largely repeats the parameter names. It is not overly verbose, but could be more concise by integrating parameter descriptions naturally.
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?
Despite required parameters and an output schema (presumed), the description does not explain what the tool returns or any post-conditions. For a submission action with three required parameters, more context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, yet the description adds minimal meaning beyond parameter names. 'places' is described as 'Selected place objects from Pine's provided options,' which is vague. session_id and message_id are merely restated. The description does not explain format, structure, or constraints of the objects.
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: 'Submit a location selection from options Pine provided.' It specifies verb ('Submit') and resource ('location selection') and implies it's from prior options. However, it does not explicitly distinguish from the sibling tool 'pine_send_location_response', which could be ambiguous.
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 alternatives like pine_send_location_response or pine_send_form_response. The description lacks any context about prerequisites or scenarios.
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 provided, the description carries full burden for behavioral disclosure. It fails to mention effects (e.g., whether stop is immediate or graceful), returned output (despite existing output schema), or 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short, which could be efficient, but it lacks necessary detail. Every sentence should earn its place; this one does not fully serve the agent.
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?
Given the lack of parameter descriptions, no annotations, and an existing output schema, the description is incomplete. It does not specify what the return value indicates or what happens if the task is not running.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The sole parameter 'session_id' has no description in the schema (0% coverage) and the tool description does not explain its purpose, required format, or how to obtain it. This is a critical gap.
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 clearly states the action ('Stop') and the resource ('a running Pine AI task'). It directly contrasts with the sibling 'pine_task_start', providing clear differentiation.
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 on when to use this tool versus alternatives like 'pine_task_start' or other session-related tools. The description lacks context on prerequisites or conditions for stopping a task.
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 full burden. It states 'Get the web URL' implying a read operation, but does not disclose behavioral traits such as whether the session must be active, whether the URL expires, or any authentication requirements. The description lacks sufficient behavioral context.
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 two sentences long with no fluff. The first sentence clearly states the primary function, and the second adds usage context. It is front-loaded and every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that an output schema exists (so return values are documented elsewhere) and the tool is simple with one parameter, the description provides the core purpose and usage context. However, it could be more complete by mentioning that the URL is specifically for the session identified by session_id, but overall it is adequate for a basic tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage for the single parameter 'session_id'. The tool description does not add any meaning beyond the parameter name; it fails to explain what constitutes a valid session_id, its format, or scope. With no schema description and no additional context in the description, the agent has insufficient information to correctly provide the parameter.
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 clearly states 'Get the web URL for a session' using a specific verb ('Get') and resource ('web URL for a session'). It distinguishes from siblings like pine_session_get (returns session details) and pine_session_create (creates a session) by focusing on URL retrieval. Additionally, it provides context on sharing for tracking/payments/credits.
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 when to use the tool (to obtain and share a session URL), but does not explicitly state when not to use it or mention alternatives among siblings such as pine_session_get for retrieving full session details. Guidance is implied rather than explicit.
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 must disclose behavioral traits. It only states 'update' and recommends confirmation, but does not explain side effects (e.g., notifications sent, permissions required, reversibility). This is insufficient 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with a front-loaded purpose sentence followed by a clear parameter list. No unnecessary information is included, making it efficient for an agent to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (4 required params, output schema present), the description covers the core purpose and parameter meanings. However, it lacks behavioral context (e.g., error handling, state changes) that would be expected without annotations.
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 Args section provides meaningful descriptions for all four parameters, compensating for the 0% schema coverage. It clarifies purpose (e.g., 'session with the scheduled call') and format (ISO 8601 for time), though more detail on expected values could improve.
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 tool updates a scheduled call reminder, using a specific verb and resource. It distinguishes from sibling tools like pine_session_create or pine_send_message by focusing on reminder updates.
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 advises to 'confirm timing with the user first,' providing a basic usage guideline. However, it lacks explicit when-not-to-use or alternative tool suggestions, which limits its utility for selection.
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 provided; description only states 'delete' without disclosing permanence, side effects, auth requirements, or rate limits.
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?
Very concise two-line description with front-loaded action, though the Args block adds minimal overhead.
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?
Adequately covers the simple tool with 1 parameter and output schema; lacks error or return info but sufficient for basic deletion.
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 coverage is 0%, but description adds meaning: 'attachment_id: The attachment ID from pine_upload_attachment' clarifies the parameter source beyond schema type.
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?
Clearly states 'Delete a previously uploaded attachment' with specific verb and resource, distinguishing from sibling tools like pine_upload_attachment.
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?
Implies usage after uploading an attachment via the mention of 'attachment_id from pine_upload_attachment', but lacks explicit guidance on when to use vs alternatives or when not to use.
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?
No annotations are provided, so the description carries the full burden. It states 'Get session details', indicating a read operation with no side effects. However, it does not disclose error handling, authentication requirements, rate limits, or what happens if the session_id is invalid. The description is adequate but not rich in behavioral context.
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, straightforward sentence without unnecessary words. It is front-loaded with the purpose. However, it could be slightly more informative about the output or limitations without becoming verbose.
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 has one parameter and an output schema, so the description is minimally complete. However, it does not explain the return values (though the output schema exists) or error scenarios. Given the simplicity of the tool, the description is adequate but could provide more context for proper selection among the many sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, meaning the parameter 'session_id' has no description in the schema. The tool description does not explain the format, source, or constraints of session_id. This provides no added meaning beyond the schema's type declaration.
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 clearly states the verb 'Get', the resource 'session details', and lists the fields 'state, title, and timestamps'. It distinguishes this tool from sibling tools like pine_session_list (which lists sessions) and pine_session_create/delete/url (which perform different actions).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is used to retrieve details of a specific session, but it does not provide explicit guidance on when to use it versus alternatives like pine_session_list for listing sessions or pine_session_url for getting a URL. The context is clear but lacks exclusion or alternative recommendations.
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 full burden. It indicates mutation ('share on social media') but does not disclose side effects, authentication needs, rate limits, or what happens upon sharing. The behavioral disclosure is minimal.
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 two sentences with a clear arg list, no redundancy. It presents the purpose upfront and then lists parameters efficiently. Every sentence contributes value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (3 required params, output schema exists), the description covers the essential purpose and parameters. However, it misses contextual information such as authentication requirements or the need for a completed session. An output schema exists, so return value explanation is optional.
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 provides brief descriptions for each parameter: session_id as 'The completed session', platform with enumerated options, shared_url as 'URL of the social media post'. This adds meaning but lacks detail on formats or constraints.
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 clearly states the tool's action: 'Share completed task results on social media to earn Pine credits.' It identifies the specific verb ('Share'), resource ('completed task results on social media'), and immediate benefit ('earn Pine credits'). This distinguishes it from sibling tools focused on authentication, sessions, and attachments.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage after completing a session (via the 'session_id' parameter) but does not explicitly state when to use or avoid this tool, nor does it mention alternatives or prerequisites. Guidance is only implicit.
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 present, so the description must fully disclose behavior. It only states the action of submitting coordinates without explaining side effects, such as whether a message is sent, data is persisted, or authentication is required. This is insufficient for an agent to understand implications.
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 very short and front-loaded with the purpose. However, the placeholder '[LOCATION NEEDED]' is unclear and slightly detracts from professionalism. Overall, it is efficiently written with docstring-style parameter descriptions.
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 tool with 4 simple string parameters and no nested objects, the description covers the purpose and parameter meanings adequately. However, it lacks context about return values, error handling, or prerequisites like session validity. An output schema exists but is not described, leaving gaps.
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 schema has 0% description coverage, but the tool description provides clear parameter semantics: 'session_id: The session requesting the location', 'message_id: The location request's message_id from pine_get_history', etc. This adds significant meaning beyond the raw schema.
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 clearly states 'Submit location coordinates for a [LOCATION NEEDED] event,' specifying the action and target. It distinguishes from sibling 'pine_send_location_selection' by focusing on raw coordinates.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by saying 'Ask the user if unknown,' but does not explicitly state when to use this tool versus alternatives like pine_send_location_selection. No exclusion criteria 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.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It indicates a read-like operation (listing) but does not disclose behavioral traits such as auth requirements, rate limits, or safety guarantees. The description adds minimal insight beyond the schema.
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 extremely concise, with a clear one-line summary followed by a structured parameter list. Every sentence adds value and the format is front-loaded, making it easy for an AI to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema (not shown but exists), the description adequately covers input parameters and basic behavior. It explains filtering and pagination, which is sufficient for a listing tool. However, it could mention that results are returned as a list.
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?
With 0% schema description coverage, the description compensates by explaining each parameter's purpose and giving examples (e.g., state filter values). It adds meaning beyond the schema, though a full list of possible state values would improve completeness.
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 tool lists Pine AI sessions with an optional state filter. The verb 'List' is specific and the resource is well-identified, but it does not explicitly differentiate from sibling tools like pine_session_get (single session retrieval), which would improve clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for listing sessions with optional filtering, but does not provide explicit guidance on when not to use it or mention alternatives such as pine_session_get for individual sessions. Only inferred usage context is given.
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 provided; description does not disclose side effects, auth requirements, or rate limits. Only preconditions are given.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, focused and efficient. However, backticks around signal names are unnecessary but not detrimental.
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?
Has output schema but no info on return values. Describes preconditions but not overall behavior. Adequate but incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only parameter session_id is not explained in description; schema coverage is 0%, so no added meaning beyond schema.
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 clearly states the tool starts task execution after billing confirmation. It distinguishes from sibling tool pine_task_stop.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly provides when to call (after billing signals) and when not to call (if task auto-started). Clear context.
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. It mentions return values (session_id, web URL) but does not disclose behavioral traits such as authentication requirements, rate limits, or side effects. For a session creation tool, these are important gaps.
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 concise (two sentences) and front-loaded: it states the purpose first, then the output, then the next action. Every sentence adds value with no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool (no parameters) and the existence of an output schema, the description covers the purpose, return values, and next step. It lacks behavioral context (e.g., authentication), but with zero parameters and no annotations, it is mostly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, and the schema description coverage is 100%. The description adds value beyond the schema by explaining what the tool returns and the next step, which is not in the schema.
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 clearly states the action (create a new Pine AI session) and the purpose (start a customer service task). It distinguishes this tool from siblings like pine_session_get, pine_session_list, and pine_session_delete by being the creation tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says when to use this tool (to start a customer service task) and provides a direct next step (call pine_send_message). It does not explicitly state when not to use it, but the context is clear among sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but the description explains the 'force_delete' parameter, revealing that deletion may be blocked if the session has an active task. This adds valuable behavioral context beyond the schema.
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 brief and front-loaded with a clear purpose; each sentence serves a purpose. However, it could be slightly more polished with a note on return values.
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?
While the description clarifies the parameters, it lacks information about what the tool returns or potential side effects. An output schema exists but is not visible in the context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, and the description compensates fully by explaining both parameters: 'session_id' as the target, and 'force_delete' as a way to override active tasks.
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 clearly states 'Delete a Pine AI session' with a specific verb and resource. Among sibling tools, it's distinct from other session operations and delete operations.
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 deletion usage but does not explicitly state when to use it versus alternatives, nor does it exclude cases.
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?
No annotations provided, so description carries the burden. It discloses that it returns attachment metadata and the file is uploaded for a session. However, it omits details like file size limits, allowed types, auth requirements, or whether uploads are permanent. Adequate but could be more informative.
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?
Three sentences, front-loaded with purpose, then usage instruction, then parameter documentation. No wasted words, efficient structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity (1 param, no enums, output schema exists), the description covers purpose, usage, and input. Missing potential constraints like file size or type, but overall sufficient for a basic upload tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description adds 'Absolute path to the file to upload' to the parameter file_path, clarifying its purpose and format. This compensates for the missing schema description.
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 clearly states the verb 'Upload', the resource 'file for a Pine AI session', and enumerates example types (bill, screenshot, document). It distinguishes from siblings like pine_delete_attachment (delete) and pine_send_message (use the attachment).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs to pass the returned metadata to pine_send_message via the attachments parameter, indicating a clear workflow. Lacks explicit exclusions or when-not-to-use, but context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes the action (email sent, request_token returned) and user interaction (ask user for code). Without annotations, this disclosure is sufficient for a simple code request. Lacks details on rate limits or email delivery guarantees, but not critical.
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?
Three sentences, step-numbered, no redundancy. Each sentence adds value: action, user instruction, next step.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present (though not shown), the description covers the purpose and flow. Missing potential error cases or prerequisites, but overall adequate for a simple authentication step.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter (email). The description mentions 'Pine AI email' but does not specify format, validation, or constraints. Schema coverage is 0%, so description should compensate but does not sufficiently clarify parameter semantics.
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 clearly states the action: 'Send a verification code to the user's Pine AI email.' It identifies itself as Step 1 and distinguishes from the sibling tool pine_auth_verify_code by outlining the sequential flow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool (as Step 1) and when to use the sibling (Step 2: call pine_auth_verify_code after receiving the code). It advises asking the user to check email and spam.
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?
No annotations are provided, so the description must cover behavioral aspects. It warns against guessing codes and provides an example for the data parameter, but it does not disclose return values, error handling, side effects, or whether the action is destructive. With 0% schema coverage, more detail would be beneficial.
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 concise: a brief main sentence followed by a clear Args list. Every sentence adds value, and the warning is front-loaded. No unnecessary words.
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?
The description covers the main purpose and parameter semantics, and integrates the warning. Given the presence of sibling tools and the existence of an output schema (though not detailed), the description is mostly complete. It could be enhanced by describing the response or error scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant meaning beyond the schema by explaining each parameter: session_id ('session requesting authentication'), message_id ('auth request's message_id from pine_get_history'), and data (with an example). Since schema coverage is 0%, this is essential and well-done.
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 clearly states the verb 'Submit' and the resource 'OTP/verification code' within the context of an '[AUTH NEEDED] event'. It distinguishes from siblings like pine_auth_request_code (which likely requests a code) and pine_auth_verify_code.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes a crucial guideline: 'ALWAYS ask the user for the code first — never guess or hallucinate'. It implicitly sets the context of use after an auth request. However, it does not explicitly state when not to use this tool or provide direct comparison with siblings.
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, the description carries full burden for behavioral disclosure. It describes the action (send message) and that it can take JSON form data, but does not address side effects, whether the operation is asynchronous, error behavior, or if it modifies state beyond sending. Lacks depth on behavioral traits.
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 concise (6-7 lines) and well-structured: primary purpose, secondary use case, follow-up suggestion, then parameter descriptions. Every sentence adds value without redundancy.
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 tool with 3 parameters, no annotations, and an output schema, the description covers main and alternative uses and explains parameters. However, it could mention that the tool returns a response or that it is non-blocking. It adequately directs users to pine_get_history for the response.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so description must explain all parameters. It does so explicitly: session_id identifies the session, content can be text or JSON, attachments are optional metadata from pine_upload_attachment. This adds meaning beyond the schema's raw types.
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?
Description states the tool is used to 'Send a message to Pine AI' and also 'submit form answers as JSON' when pine_send_form_response is not applicable. It distinguishes from siblings like pine_get_history, making the purpose clear and specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly mentions when to use the tool (describe task, answer questions, provide info) and when to use an alternative (pine_send_form_response is not applicable). Suggests using pine_get_history afterward, providing clear context for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses that on success, credentials are activated and all Pine tools become available. This is a significant behavioral effect. However, it does not detail potential failure modes or side effects, but given the simplicity of the action, it is sufficiently transparent.
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 extremely concise, consisting of only two sentences. The first sentence front-loads the purpose and step number, and the second provides usage details and outcome. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that an output schema exists, the description need not explain return values. It explains the activation effect on other tools, which is the most important context for an auth verification step. The description is complete for its complexity level.
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?
Although schema description coverage is 0%, the description adds meaning to all three required parameters. It explains that 'request_token' comes from pine_auth_request_code and 'code' is from the user. The 'email' parameter is implicit but clear. This adds value beyond the bare schema.
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 clearly states it is step 2 of the auth flow, verifying an email code and activating Pine AI credentials. It specifies the verb 'verify' and the resource 'email code', and distinguishes from the sibling tool pine_auth_request_code.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly mentions using the request_token from pine_auth_request_code and the code from the user. It also states the outcome (all Pine tools become available). It provides clear context for when to call this tool as part of a two-step process, though it does not explicitly state when not to use it.
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?
No annotations provided, so description carries full burden. It describes the action as submitting a form (write operation) but does not disclose potential side effects, error scenarios, or idempotency. It also does not describe the return value despite an output schema existing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is concise: one-line purpose, then usage guidelines, then parameter list. Every sentence adds value with no redundancy.
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?
Covers purpose, usage, and parameters well. Lacks information about output/return values (even though output schema exists) and error handling. For a form submission tool, this is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 0% description coverage, but the description compensates fully by explaining each parameter: session_id is 'The session containing the form', message_id is 'The form's message_id from pine_get_history output', and form_data is '{"field_name": "value"} pairs matching the form fields'. This adds crucial meaning beyond types.
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 explicitly states 'Submit a form shown in pine_get_history as [FORM]', clearly identifying the action and resource. It distinguishes itself from siblings like pine_get_history (which retrieves history) and other send tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit guidance: 'Fill fields you know; ask the user for unknowns (especially preferences or security info). Use exact option labels for select fields.' This tells the agent when to act autonomously vs. defer to user, and how to handle specific field types.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that the tool polls history, does not stream, and lists special markers to look for, giving insight into expected responses. It does not cover rate limits or error conditions, but the behavioral details are adequate.
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 concise and front-loaded: a one-sentence purpose, followed by usage guidance, a list of markers, and parameter descriptions. Every sentence adds value without redundancy, achieving efficient communication.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (4 parameters, polling behavior, special markers), the description covers all necessary aspects: purpose, usage timing, behavioral hints, and parameter details. The presence of an output schema means return values need no explanation, and the description is complete for an AI agent to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description adds clear semantics for all 4 parameters: session_id, max_messages, order, and from_message_id. It explains their purpose and defaults, compensating fully for the missing schema descriptions.
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 'Poll Pine's conversation history — the core way to see replies (no streaming).' This clearly identifies the tool's verb (Poll) and resource (conversation history), and distinguishes it from siblings like pine_send_message and pine_session_create, which have different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description says 'Call after sending a message or starting a task. Wait a few seconds between polls,' providing clear context on when to use the tool. It does not explicitly state when not to use it or mention alternatives, but the guidance is sufficient for typical use cases.
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:

[![pine-mcp-server MCP server](https://glama.ai/mcp/servers/19PINE-AI/pine-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/19PINE-AI/pine-mcp-server)

Score Badge

Copy to your README.md:

[![pine-mcp-server MCP server](https://glama.ai/mcp/servers/19PINE-AI/pine-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/19PINE-AI/pine-mcp-server)

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/19PINE-AI/pine-mcp-server'

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