@theyahia/amocrm-mcp

Server Quality Checklist

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

Latest release: v2.0.2
Disambiguation5/5
Each tool maps to a distinct resource and action, such as list_leads vs get_lead vs create_lead, and list_unsorted/accept_unsorted are clearly separate from regular lead tools. No two tools appear to do the same job.
Naming Consistency5/5
Tool names consistently use lowercase snake_case verb_noun patterns like list_leads, create_contact, complete_task, and accept_unsorted. The bare 'search' is a reasonable exception for a universal action and does not break the overall convention.
Tool Count3/5
At 19 tools, the set falls into the heavy 16-25 range and begins to feel borderline bloated, even though the CRM domain covers many entities. The organization by entity helps, but the count is above the ideal 3-15 sweet spot.
Completeness3/5
Core lead and task workflows are well covered, but contacts and companies lack update/delete operations, there is no get_company, and unsorted leads can only be accepted, not declined. These are notable lifecycle gaps that agents may need to work around.
Average 3.8/5 across 19 of 19 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues 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 passing
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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only restates the search functionality already present in the query parameter schema; it does not disclose pagination behavior, return shape, whether an empty query returns all contacts, or any permissions/read-only guarantees.
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?
Two short, front-loaded sentences with no filler. The core purpose and search scope are stated efficiently, and every word contributes to understanding.
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 schema fully documents parameters, and the tool is a relatively simple read/list operation. However, with no output schema and no annotations, the description does not explain the response shape, pagination semantics, or how to choose this over the sibling 'search' tool, leaving some important context missing.
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 100%, so all four parameters are already documented in the input schema. The description adds no new parameter-level meaning beyond what the schema provides, which keeps this at the baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Search and list contacts in amoCRM.' It also clarifies the searchable fields, which helps an agent understand the tool's scope. However, it does not explicitly distinguish itself from the broad sibling tool 'search' or from 'get_contact' beyond the list-versus-fetch implication.
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 intended use is implied: use this tool to browse or search contacts across name, phone, and email. No explicit guidance is given about when to prefer this over sibling tools such as 'search' or 'list_leads', and no exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It conveys the write nature ('Add a note') but does not disclose what happens on success, error behavior for a nonexistent entity_id, side effects such as timeline entries or notifications, or how the note types affect behavior beyond the schema's enum.
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?
Two compact sentences with no filler. The first sentence front-loads the core action and target entities; the second earns its place by expanding the scope of supported note types. Nothing is redundant with the schema or name.
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 simple 4-parameter create tool, the core semantics are adequately covered by the description plus a fully documented schema. However, with no annotations and no output schema, the description leaves prerequisites (entity must exist) and success/return behavior unaddressed, which an agent invoking a write operation would benefit from knowing.
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 100%, so the baseline is 3 — the schema already documents all four parameters. The description adds a mild semantic gloss by framing the note_type enum values as 'incoming/outgoing call logs' and 'service messages,' but it adds no meaning for text or entity_id beyond what the schema states.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Add') and resource ('a note to a lead, contact, or company'), which aligns with the tool name and the entity_type enum. It differentiates cleanly from all siblings, which cover leads, contacts, companies, tasks, and events but include no other note-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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the purpose: use this tool when a note must be attached to a lead, contact, or company. The second sentence sketches supported scenarios (common notes, call logs, service messages), but there is no explicit when-to-use guidance, prerequisites (e.g., the entity must exist), or exclusions — though no sibling competes for the same job.
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 must carry the behavioral transparency burden. It clearly implies a read-only list operation but does not disclose pagination behavior, default ordering, how filters combine, or response shape.
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 short, efficient sentences with the core action front-loaded and no wasted words. It quickly tells the agent what the tool does and the available filtering dimensions.
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 schema fully documents all six optional parameters, and the tool is a relatively simple list operation. However, with no output schema or annotations, the description omits return format, default pagination behavior, and filter-combination semantics.
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 100%, so each parameter is already documented. The description's filter list adds high-level context but no additional semantic meaning beyond what the input schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('List') and resource ('tasks in amoCRM'), and names concrete filter dimensions (entity, completion status, responsible user). This clearly distinguishes it from sibling tools like list_leads, list_contacts, and list_companies.
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 the tool's purpose but does not explicitly state when to use it versus alternatives or note exclusions. Sibling context suggests this is the primary task-listing tool, but no direct comparison is provided.
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?
Annotations are absent, so the description carries the full burden of behavioral disclosure. It only restates the create action and gives a parameter hint; it does not mention required permissions, idempotency, side effects, or response behavior. For a mutation tool, this is minimal disclosure.
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?
Two sentences with no filler, front-loading the core action and adding one actionable hint. Every word earns its place.
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 essential parameters are fully documented in the schema and the custom-field hint adds useful context for the optional payload. However, with no annotations and no output schema, the description does not state what a successful creation returns or what prerequisites apply, leaving a noticeable completeness gap.
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 coverage is 100%, so the schema already documents all three parameters and their nested structure. The description adds practical meaning by telling the agent to use custom_fields_values for address, website, etc., which clarifies the purpose of the most complex parameter beyond 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?
States a specific verb and resource: 'Create a new company in amoCRM.' This clearly distinguishes it from sibling tools like create_lead, create_contact, and create_task. The follow-up hint about custom_fields_values reinforces the resource type without ambiguity.
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?
No explicit when-to-use or when-not-to-use guidance is given relative to sibling creation tools. The intended usage is implied by the verb and resource name, and the custom_fields_values hint addresses how to populate optional data, but no alternative-selection conditions or exclusions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of disclosing side effects and outcomes, yet it only restates the create action and input requirements. It says nothing about response format, permissions, idempotency, or consequences of creating duplicate leads.
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?
Two short sentences front-load the core action and then list the key input constraints. Every word contributes; there is no filler or repetition.
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 straightforward create operation with fully documented parameters, the description is minimally sufficient: it names the required field and signals which optional fields are available. However, since there is no output schema or annotations, the absence of any mention of return values or failure behavior leaves a notable gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds a little value by grouping parameters into required vs optional and using friendly labels ('pipeline', 'status', 'responsible user'), but it does not deepen understanding beyond what the schema already documents.
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?
States a specific action ('Create'), a distinct resource ('lead (deal)'), and the system ('amoCRM'). The name alone already distinguishes it from siblings like create_contact and create_company, and the description reinforces the target resource.
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 tool's purpose statement makes it clear it is for creating leads, and there is no competing create-lead sibling, so the appropriate use case is unambiguous. It adds a prerequisite ('Requires a name') and lists optional fields, but does not explicitly contrast with alternatives such as create_contact or create_company.
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 the behavioral burden. It clearly states the creation action and identifies two meaningful field constraints (Unix timestamp for complete_till, enumerated task types). It does not mention what the response contains, permission requirements, or side effects beyond creation.
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?
Two tight sentences, no filler. The core action and the two most important field semantics are front-loaded, and every clause adds information needed to invoke the tool correctly.
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 creation tool with 6 parameters and no output schema, the description covers the essential semantics but leaves out return behavior and any guidance on optional fields (task_type_id, responsible_user_id) or prerequisites. The schema fills parameter details, so this is adequate but not complete.
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 100%, so the baseline is 3. The description adds a little context by calling out complete_till as a Unix timestamp and mapping task type IDs to labels, but these details already appear in the schema, so it does not materially exceed baseline.
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 names a specific verb and resource ('Create a task') and specifies the linkage targets (lead, contact, or company), which clearly separates it from sibling tools like create_lead, create_company, list_tasks, and complete_task.
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?
Usage is implied by the verb and resource: call this when you need to create a task. However, it does not explicitly say when to prefer this over add_note or complete_task, nor does it state any exclusions or prerequisites such as the linked entity needing to exist.
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 the full burden of behavioral disclosure. It communicates that the tool mutates a lead but does not reveal whether the update is partial or full replacement, what side effects occur on related entities, what permissions are needed, or what the response contains. This is a significant transparency gap for a write operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no filler. It states the core action first, lists the relevant fields, and adds one useful application example, all without redundancy.
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 schema fully documents the parameters and the description provides a clear primary use case, so an agent can invoke the tool correctly. However, there is no output schema and no annotation coverage, and the description does not explain return behavior, whether unspecified fields remain untouched, or any operational constraints, leaving some ambiguity for a mutation tool.
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 100%, so every parameter already has a description and the schema carries the heavy lifting. The description paraphrases the fields ('change name, price, status...') and adds a slight semantic grouping, but it does not meaningfully go beyond what the input schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Update an existing lead') and enumerates the key fields that can be changed, which clearly distinguishes it from read tools like get_lead/list_leads and from create_lead. The added use case 'moving deals between stages' further sharpens the intended purpose.
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 phrase 'existing lead' implies this is for modifying already-created leads rather than creating new ones, and 'Useful for moving deals between stages' gives a concrete application. It does not explicitly name alternatives or state when not to use it, but the context is clear enough for an agent to choose it over create_lead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of explaining side effects. It discloses the core state change and optional parameters, but does not clarify what happens to the original unsorted entry, whether defaults are used for omitted fields, or whether the operation requires special permissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, well-structured sentence that states the action, outcome, and optional fields without repetition or filler. Every clause 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?
For a relatively simple operation with full schema coverage, the description provides enough context to invoke the tool correctly: the required UID, the state change, and optional fields are all clear. Minor gaps remain around default behavior and return value, but they do not seriously impede correct usage.
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 100%, so all four parameters already have clear descriptions. The description's mention of 'pipeline, status, and responsible user' mirrors the schema and adds no additional semantic nuance beyond what the schema provides.
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 names the action ('accept'), the resource ('unsorted lead'), and the outcome ('moves it into a pipeline as a real lead'). It distinguishes this tool from sibling read/list tools by describing a state transition from unsorted to real lead.
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 usage context is implied: use this when you have an unsorted lead to convert into a real pipeline lead. However, it does not explicitly mention when not to use it or name alternatives like create_lead for starting from scratch.
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 behavioral burden. It discloses the mutating effect and the side effect that the result appears in the activity feed. However, it does not mention whether completion is reversible, whether existing result text is overwritten, or any permission requirements, leaving moderate 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?
Two concise sentences with no filler. The primary action is front-loaded, and the additional consequence is stated in a single follow-up sentence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter mutation tool with no output schema, the description provides enough context to invoke it correctly: what it does, what data is required, and a visible side effect. It does not describe the response format, but that is less critical given the absence of an output schema.
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?
With 100% schema description coverage, the input schema already documents both parameters adequately. The description only loosely echoes 'result text' and adds no new syntax, formatting constraints, or parameter relationships beyond 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 states a specific verb and resource: 'Mark a task as completed' and 'add a result text.' This clearly distinguishes it from sibling tools like create_task, list_tasks, and add_note, so an agent can identify its unique purpose without looking elsewhere.
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 the tool should be used when a task is done and a result needs to be recorded, but it does not explicitly state when to use it versus alternatives such as add_note or create_task. There are no exclusions or conditional routing hints.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of disclosing behavior. 'Get' clearly implies a non-destructive read operation, and the description lists the kind of information returned. It does not mention permissions, rate limits, response format details, or any edge behavior, though these are less critical for a simple read-only account endpoint.
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?
Two sentences with no filler. The main purpose is front-loaded, and the optional parameter usage is stated directly and economically. 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?
For a simple tool with one optional parameter, the description is nearly complete: it names the account-scope resource, lists representative returned fields, and explains how to request additional data. There is no output schema, so exact return structure is not specified, but the high-level response categories are sufficient for an agent to understand what it will receive.
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 100%, so the baseline is 3. The description adds some semantic color by explaining that 'with' can enrich the response with users_groups, task_types, and amojo_id, but this largely mirrors the schema's enum list. It does not significantly deepen meaning beyond the structured definition.
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 identifies the action ('Get'), the resource ('current amoCRM account'), and the kind of data returned ('name, plan, users, task types, etc.'). It is immediately distinguishable from the sibling lead/contact/task tools because it targets account-level metadata.
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 use when account-level information is needed, and the 'with' instruction gives operational guidance for extending the response. However, it does not explicitly state when to prefer this tool over an alternative, mention prerequisites, or describe exclusions.
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 the full burden. It conveys that this is a read operation returning full details and that related entities can be embedded, but it does not disclose response format, error behavior, or permission requirements. It is not misleading, but it leaves meaningful behavioral aspects implicit.
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 short sentences with no filler. The core purpose is front-loaded, and the optional parameter guidance follows immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple get-by-id tool with one required and one optional parameter, the description is nearly complete. It covers the primary action and the main use of 'with', while the schema covers the remaining enum values. A slightly fuller mention of the other embeddable entities would make it flawless.
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 100%, so the schema already documents both parameters. The description adds light value by clarifying 'with' includes linked contacts and catalog elements, but omits loss_reason and source_id from that clarification. Overall, it does not substantially exceed the schema's own parameter 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 a specific verb ('Get'), resource ('a single lead'), lookup key ('by ID'), and expected richness ('full details'). It clearly distinguishes this tool from list_leads and get_contact without needing to open the schema.
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 the common case of fetching one lead by ID and provides parameter guidance for 'with'. However, it does not explicitly contrast this with list_leads or state when not to use it, so the guidance is more implied than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of disclosing behavior. It does convey that this is a search/list operation and explains the embedding behavior of 'with,' which is useful. It does not explicitly state that the operation is read-only or describe response/pagination behavior, but the verb 'list' reasonably implies a non-destructive read.
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 no filler. The core purpose is front-loaded, and the practical 'with' usage tip is placed second, making the entire definition easy to scan and understand.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list/search tool with fully documented parameters and no output schema, the description covers the essential operation and the most notable optional behavior. It omits explicit mention of pagination defaults or response shape, but those are either in the schema or reasonably inferable from the tool name and context.
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 100%, so the schema already documents page, with, limit, and query. The description adds a brief hint to use 'with' for embedding leads and contacts, but this largely restates what the schema's enum already communicates. No additional semantic depth is added.
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 verb and resource: 'Search and list companies in amoCRM.' It also explains a key capability, embedding linked leads and contacts via 'with,' which helps distinguish it from sibling list tools like list_leads and list_contacts.
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 resource name makes it obvious this tool is for companies, and the description implies it should be used when company data is needed. However, it does not explicitly contrast it with list_leads, list_contacts, or search, leaving the choice to inference rather than direct guidance.
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 behavioral disclosure burden. It does convey that this is a read-style listing operation and gives examples of returned event categories, but it omits behavioral details such as auth requirements, rate-limit behavior, ordering, or whether results are limited to a default time range.
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 no wasted words. It front-loads the core purpose ('List events (activity log) in amoCRM'), then states the filters and output content concisely.
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 five optional parameters, full schema coverage, and no output schema, the description does a reasonable job by explaining what events are shown and how to filter. It falls slightly short of fully complete because there is no output schema and no mention of response shape, pagination behavior beyond the schema defaults, or ordering.
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 100%, so the baseline is 3. The description restates the main filtering parameters (entity type, entity ID, event type) but adds no meaning beyond the schema; it does not explain combinations, precedence, or edge cases.
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 identifies the resource as 'events (activity log)' in amoCRM and the operation as listing them, which is distinct from the sibling tools that list leads, contacts, companies, or tasks. It also communicates the filtering dimensions and examples of the event types returned.
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 this tool—when the agent needs an activity log or event history—but it does not explicitly say when not to use it or name alternatives. There is clear context but no exclusionary guidance relative to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reasonably implies a read-only list/search operation and adds useful context by saying the 'with' parameter embeds contacts or loss reasons. However, it does not describe pagination behavior, response format, or any caveats such as rate limits or required permissions.
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 and every sentence earns its place: the first establishes the core action and resource, the second summarizes key capabilities. It is front-loaded, free of filler, and avoids repeating obvious schema details.
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 filtered-list tool with 100% schema coverage, the description is nearly complete: it names the core operation, available filters, and the embedding option. The main gap is the lack of an output schema means the description could have briefly noted the response shape, but the tool's purpose and schema are sufficient for an agent to invoke it correctly in most cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides complete descriptions for all 6 parameters, so the baseline is 3. The description adds only minor reinforcement—for example, it highlights 'with' for embedding contacts or loss reasons—but does not meaningfully extend what the schema already states about 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 uses a specific verb ('Search and list') with a clear resource ('deals (leads) in amoCRM') and names concrete behaviors: filtering by pipeline, statuses, and full-text search. It also distinguishes itself from sibling tools like get_lead or list_pipelines by indicating it lists multiple leads with optional embedded relations.
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 clearly communicates what the tool does and what filtering/embedding options are available, which implies it should be used for broad lead listing/searching. However, it does not explicitly say when to prefer this tool over get_lead, search, or list_contacts, and provides no exclusion guidance for alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It does explain that it searches matching leads, contacts, and companies, but it does not mention read-only status, result ordering or grouping, pagination behavior, or how mixed entity types are returned. The min-length constraint is stated, but other behavioral limits are left to 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 one compact sentence that front-loads the core concept ('Universal search across amoCRM') and then specifies entity types and the minimum query length. There is no filler, no repetition of the tool name, and every clause adds useful information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 2-parameter tool with full schema coverage and no nested objects, the description is nearly complete: it tells the agent what is searched, the required query length, and the general scope. The main gap is the lack of any return-value description, since there is no output schema, but the result shape of a universal search is reasonably inferable.
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 100%, so the schema already documents both query and limit with meaningful descriptions. The tool description only repeats the query min-length constraint and adds no additional semantic value for either parameter, which matches the baseline for full coverage.
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 names a specific action ('search'), a scope ('across amoCRM'), and a clear resource set ('leads, contacts, and companies'). This distinctly differentiates it from the entity-specific list_*/get_* sibling tools.
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 word 'Universal' implies this is the cross-entity search tool, and 'finds leads, contacts, and companies' suggests its scope. However, it never explicitly states when to use this over list_leads/list_contacts/list_companies or when not to use it, so the guidance is mostly implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral disclosure burden. It clearly signals a mutating create operation and hints at the custom-fields mechanism. However, it does not disclose response format, required-field expectations, permissions, or potential side effects, which is a notable gap for an unannotated write operation.
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?
Two short sentences with zero filler. The primary action is front-loaded, and the custom-fields tip is relevant enough to earn its place.
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 description and schema together cover the core operation and all parameters. Missing context includes explicit guidance on when to prefer this tool over siblings (though implied), whether any field is effectively required despite schema marking none, and what the response looks like. Adequate for a simple create, but not fully complete.
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 100%, so all five parameters are already documented. The description's pointer to custom_fields_values for phone/email largely echoes the schema's own description ('Custom field values (phone, email, etc.)'), adding no new semantic content. Baseline 3 applies.
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 the specific verb 'Create', the resource 'contact', and the platform 'amoCRM'. It clearly distinguishes this tool from sibling tools like create_lead and create_company. Mentioning custom_fields_values for phone, email, and other fields adds useful specificity.
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 makes the use case clear: creating a new contact in amoCRM. This implies when to use it over list/get tools and other create tools, though it does not explicitly state exclusions or alternatives. The practical hint about custom_fields_values provides light usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal that the result includes full details and custom fields, which is useful, but it does not mention error behavior, auth requirements, or whether related entities are embedded by default. This is a moderate gap for a read tool with no annotation safety signals.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single clear sentence with no filler. The core purpose is front-loaded ('Get a single contact by ID') and the additional detail about custom fields 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?
For a simple get-by-ID tool, the description covers the main use case and return content. It does not describe not-found behavior, but the input schema and simple design make that a minor omission. Given no output schema or annotations, the description is reasonably complete for the tool's complexity.
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 100%, so the input schema already documents both parameters adequately. The description adds general context about returned details but does not add meaning to the 'with' parameter or its enum values. Baseline 3 is appropriate because the schema carries the parameter documentation burden.
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 a specific action ('Get'), a specific resource ('a single contact by ID'), and the scope ('full details including custom fields'). It distinguishes itself from list_contacts by emphasizing 'single' and from get_lead by naming contacts specifically.
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 makes it evident the tool is for retrieving one specific contact rather than listing contacts, which provides clear context for when to use it. However, it does not explicitly name alternatives or say when not to use it, such as when retrieving leads instead.
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 the disclosure burden. It makes clear the returned set is limited to unsorted leads, but it does not explicitly state that listing is read-only or has no side effects, nor does it mention ordering or pagination behavior. The verb 'list' implies safety, but the absence of annotations leaves some burden unmet.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that front-loads the core action and resource, then adds the two clarifications that matter: the source of the leads and their pending state. There is no redundant wording or repetition of schema information.
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 is adequate for a zero-required-param list tool: it identifies the resource, the filter (unsorted), and the reason (accept/decline). Without an output schema, it leaves the exact response shape unstated, and it could have pointed to accept_unsorted as the follow-up step, but these are minor gaps.
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?
All three parameters (page, limit, pipeline_id) are fully described in the input schema, so the description need not repeat them. The description adds no semantic detail about how filtering or pagination interacts with the unsorted status, which is acceptable given 100% schema coverage.
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 opens with a specific verb and resource, 'List incoming unsorted leads,' and immediately characterizes the subset: leads from forms/email parsing that await accept/decline. This differentiates it from sibling list_leads (all leads) and accept_unsorted (acting on them). There is no ambiguity about what the tool returns.
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 phrase 'that need to be accepted or declined' gives clear context for when to call this tool: when reviewing the unsorted queue before accept_unsorted. It does not explicitly name alternatives or exclusion conditions, so it stops short of a 5, but the intended use case is obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavior. 'List all' plus 'with their statuses (stages)' transparently indicates a read-only enumeration, but it does not mention pagination, ordering, or whether any special permissions are required. The core behavior is clear, but some operational details are omitted.
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 short sentences with no wasted words. The core function is stated first, and the second sentence adds valuable guidance on why and when to call the tool.
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?
For a parameterless, read-only list tool with no output schema, the description covers the purpose, result content, and usage context. Nothing critical is missing for an agent to correctly select and invoke this 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?
The tool has zero parameters, so the schema already fully defines the input surface as empty. The description adds relevant context about what the return data contains (statuses/stages) even though no parameters need explanation, matching the baseline for parameter-free tools.
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 lists all sales pipelines along with their stages, using a specific verb and resource. It is immediately distinguishable from sibling tools like list_leads or list_contacts, which target different CRM objects.
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 provides clear context: it should be used before creating or filtering leads to understand the sales funnel structure. It does not explicitly list exclusions or alternatives, but no alternative pipeline-listing tool exists among the siblings, so the guidance is sufficient.
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:

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

Score Badge

Copy to your README.md:

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

Latest Blog Posts

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

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/theYahia/amocrm-mcp'

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