cowork-history

by egoughnour

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation3/5
Most tools are distinct, but history_setup_ollama_direct and history_setup_ollama overlap as two installation methods for the same software. history_system_check and history_ollama_status are also somewhat related, though they check different aspects. Descriptions help clarify, but some ambiguity remains.
Naming Consistency2/5
Naming is inconsistent: tools use two different prefixes (history_ vs cowork_history_) and mix verb-first (setup_ollama, search) with noun-first (system_check, ollama_status) patterns. This makes the tool set feel disjointed and harder to predict.
Tool Count4/5
10 tools is within a reasonable range, but four of them are dedicated to Ollama setup/status, which is an optional dependency. This makes the set slightly heavier than necessary, though each tool still serves a distinct purpose.
Completeness4/5
The core history tools cover search, list, get, projects, stats, and reindex, providing solid lifecycle coverage for querying and maintaining conversation history. Minor gaps exist, such as lack of delete or export functionality, but they are not critical for the primary use case.
Average 3.7/5 across 10 of 10 tools scored. Lowest: 3/5.
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
- Last stable release on January 30, 2026
- 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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds minimal context about what the statistics concern (conversation history and search capabilities) but doesn't disclose additional behavioral traits like performance implications or return format details, which is acceptable given annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no wasted words. It could be more informative while still remaining concise, but the current structure is efficient.
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 an output schema and safety annotations, reducing the burden on the description. However, the description is vague about what statistics are returned, how to control the response format, and when to use this tool over siblings. It is minimally adequate but leaves clear gaps.
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?
The schema has one required nested parameter 'params' with an optional response_format enum, but the description provides zero parameter semantics. With 0% schema description coverage, the description should compensate but doesn't, leaving the agent to infer how to use the parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it 'gets statistics' about conversation history and search capabilities, which is a specific verb and resource. However, it doesn't distinguish itself from sibling tools like cowork_history_list or cowork_history_get, so sibling differentiation is missing.
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. The description doesn't mention that it's for aggregate statistics rather than raw data, nor does it reference any sibling tools or exclusion scenarios.
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?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds a small bit of context about 'reconstructed paths', but no further behavioral traits like pagination, performance, or response details are disclosed.
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, focused sentence with no unnecessary words. It front-loads the core action ('List all projects') and includes a meaningful detail ('reconstructed paths'), making it highly concise and well-structured.
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 simple one-parameter tool, strong annotations, and existing output schema, the description is largely sufficient. It clearly identifies the resource and the special aspect of conversation history, though it could benefit from a brief note on when to use this over sibling tools.
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?
The schema description coverage is 0%, and the description gives no information about the response_format parameter or how to control output. The schema itself defines the enum and default, but the description adds no value toward parameter understanding.
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 all projects with conversation history and reconstructed paths, making the purpose specific. While it distinguishes from siblings by focusing on 'projects', it does not explicitly contrast with other cowork_history_* tools like search or get.
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 such as cowork_history_search or cowork_history_list. The description simply states what it does without any contextual usage direction or exclusions.
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?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is clear. The description adds behavioral context by stating the data source ('from the index') and the sorting order ('by modification time'), which goes beyond the structured annotations.
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 that conveys the core function efficiently with no filler or redundant content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
While the description states the basic purpose, it omits parameter semantics and fails to clarify usage relative to sibling tools. The presence of an output schema helps, but input parameters are undocumented, making the description insufficient for nuanced use cases like filtering by project.
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?
Schema description coverage is 0%, and the description does not explain any of the parameters (limit, project, response_format). An agent cannot infer the meaning of 'project' or 'response_format' from either the schema or the description, leaving a significant gap for correct invocation.
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 clear verb ('List') and specifies the resource ('recent Claude conversations from the index') plus ordering ('sorted by modification time'). This distinguishes it from sibling tools like search/get, which perform different 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 the tool is for viewing recent conversations but gives no explicit guidance on when to choose it over sibling tools such as cowork_history_search or cowork_history_get. There are no exclusions or alternative references.
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 full responsibility for disclosing behavior. It reveals that the tool runs 'brew install' and 'brew services', and may prompt for sudo, which is helpful. However, it does not disclose other behavioral aspects such as whether it pulls a model, modifies system state beyond installation, or the effects of different flag combinations. The pros/cons list adds context but not exhaustive transparency.
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 well-structured: a one-line summary, a prerequisite statement, a command detail, and a pros/cons list. Every sentence provides useful information without redundancy, and the most critical information (what it does) is front-loaded.
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 gives a good high-level overview but does not explain how the boolean flags (install, pull_model, start_service) interact or what the default behavior (all false) would do. This could lead to confusion about invoking the tool with no arguments. However, since the schema details each parameter and an output schema exists, the description is not severely incomplete.
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 covers 100% of the parameters with descriptions, so the description does not need to compensate. The text mentions using 'brew install' and 'brew services', which loosely maps to the install and start_service parameters, but it does not add additional semantic detail beyond what the schema already provides. Baseline 3 applies.
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's purpose: 'Install Ollama via Homebrew (macOS).' This is a specific verb (Install) plus resource (Ollama via Homebrew). However, it does not explicitly differentiate from the sibling tool history_setup_ollama_direct, though the mention of Homebrew implies the distinction.
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 provides a clear prerequisite ('Requires Homebrew pre-installed') and notes a limitation ('may prompt for sudo on first install'). It implies when to use the tool (when Homebrew is available) but does not mention alternatives like history_setup_ollama_direct or state when not to use it, leaving the guidance incomplete.
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?
Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is clear. The description adds minimal behavioral context (e.g., 'full content' suggests a complete payload), but it does not disclose anything else like pagination or rate limits. Given the annotations, a score of 3 is appropriate.
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, concise sentence that directly states the tool's purpose. No filler or redundant wording; 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 read-only tool with an output schema, the description is reasonably complete in conveying core behavior. However, it lacks guidance on optional parameters and does not explicitly state when to prefer this over sibling tools. Still, the presence of output schema and annotations reduces the burden, making this adequate.
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 description coverage is 0%, so the description must compensate. It only mentions the primary parameter 'session ID' but leaves response_format, include_thinking, and include_tool_calls without explanation. The schema provides enum/default values, but the description does not help an agent decide among the optional parameters.
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 full content of a specific conversation by session ID,' which is a specific verb-resource pair. It distinguishes from sibling tools like cowork_history_list and cowork_history_search by emphasizing 'specific conversation' and 'full content.'
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 you have a session ID and want full conversation content, but it does not explicitly mention alternatives or when not to use this tool. No exclusions or separate guidance is provided, leaving the usage inference to the agent.
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?
Annotations already declare idempotentHint=true and destructiveHint=false, and the description adds the optional embedding behavior but nothing else. The word 'rebuild' might carry a destructive connotation, but annotations counter that; no further side effects or dependencies (e.g., Ollama requirement for embeddings) are disclosed in the description 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 a single, concise sentence that is front-loaded with the primary action and qualified with the optional part. No wasted words or 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?
For a one-parameter tool with an output schema and annotations, the description is functional but somewhat underspecified. It does not mention the relationship to other tools (e.g., Ollama status/setup for embedding generation) or any post-condition behavior. The existence of sibling tools like history_ollama_status suggests that prerequisite context could be helpful, but it's not critical for basic use.
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 description mentions 'optionally generate embeddings', which aligns with the boolean parameter in the schema. However, it does not name the parameter or explain the 'requires Ollama' condition already noted in the schema. Since the schema provides a clear description, the baseline is 3, and the tool description adds only marginal value here.
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 ('Rebuild') and resource ('conversation index'), clearly distinguishing this from sibling tools like search, list, or stats. It also mentions the optional embedding generation, which immediately conveys the tool's scope.
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 purpose implies the tool is used when the index needs rebuilding, but there is no explicit guidance on when to use it versus alternatives. The context of sibling Ollama/setup tools suggests related workflows, but the description doesn't mention prerequisites or cases where this should be avoided.
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?
Annotations already declare readOnlyHint and idempotentHint, and the description adds meaningful context about the search mechanism: it combines FTS5 full-text search, macOS Spotlight indexing, and optional vector similarity requiring Ollama. This goes beyond the annotations by explaining how the search works and its dependency on external components, without contradicting the annotations.
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 and front-loaded with the core purpose. It includes useful examples that illustrate query patterns without being verbose. The structure is clear, with a brief mechanism explanation followed by examples, making it easy to scan.
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 covers the core search behavior, supported query types, and the dependency on Ollama for vector search. However, it does not explain the different search modes (auto, fts, spotlight, vector, hybrid) or the behavior when Ollama is not available. Given there is an output schema, return values are handled, but the description misses some operational details that would be useful for a tool with this level of complexity.
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?
The schema description coverage is reported as 0%, and the tool description only mentions 'project' and 'query' in examples without defining their semantics. It does not explain 'mode', 'limit', or 'response_format'. Although the schema itself provides descriptions for most parameters, the description fails to add meaningful guidance beyond what the schema already contains, especially for the 'mode' and 'limit' parameters which lack detailed explanation.
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 purpose: 'Search Claude conversation history using hybrid search.' It specifies a specific verb (Search), resource (Claude conversation history), and method (hybrid search), distinguishing it from sibling tools like cowork_history_list and cowork_history_get, which are for listing and retrieving rather than searching.
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 gives examples of different query types (natural language, keywords, exact phrases, and filters) which implies usage context, but it does not explicitly state when to prefer this tool over alternatives such as cowork_history_list or cowork_history_get. There is no mention of alternatives or exclusions, so usage guidance is only implied.
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 discloses installation location and that no sudo is required, plus cons about PATH and updates. However, it omits other behavioral traits such as idempotence, error handling, or prerequisites like internet connectivity.
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 compact, front-loaded with the core purpose, and uses a clear PROS/CONS structure that wastes no words. Every sentence conveys useful context.
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 tool's moderate complexity and presence of an output schema, the description covers the primary install behavior and trade-offs. It could mention how the optional actions (pull model, start service) relate to the install, but those are already documented in the 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?
Schema coverage is 100%, so differences in parameter behavior (install, pull_model, start_service) are already explicit in the schema. The description adds minimal beyond schema, only reinforcing the install path.
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 a specific action—'Install Ollama via direct download (macOS)'—and distinguishes it from sibling history_setup_ollama by specifying the download source and target folder (~/Applications), making its scope evident.
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 PROS/CONS lists provide implicit guidance for when to choose this method (no Homebrew, no sudo, headless) and when not (manual PATH setup, no auto-updates), though it doesn't explicitly name a sibling alternative.
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 burden. It does disclose the main behavior: returns whether Ollama is running and if the embedding model is available. However, it does not mention that the status is cached by default or that force_refresh controls staleness—this is only in the parameter schema, not the main description.
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: the first sentence states the core purpose, the second states what it returns, and the third gives a usage recommendation. Every sentence earns its place without redundancy.
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 simple status-checking tool with one optional parameter and an output schema, the description is complete: it clearly states what the tool does, what it returns, and when to use it. The output schema covers the return structure, so the description does not need to elaborate further.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers 100% of parameter information, including a description for force_refresh ('Force refresh the cached status'). The tool description itself does not add parameter semantics, but since the schema fully documents the parameter, the baseline of 3 is appropriate.
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 and resource: 'Check Ollama server status and available models.' It clearly states what the tool does, distinguishes it from sibling tools like history_setup_ollama and history_system_check by focusing on status/availability, and explicitly mentions the key outputs (running status and embedding model availability).
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 guidance: 'Use to check if semantic/vector search is available.' This indicates when to invoke the tool. It does not explicitly name alternative tools or exclusions, but the sibling context and clear 'use to' framing give adequate direction without confusion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the specific system components checked (macOS, Apple Silicon, RAM, Homebrew), offering useful context. However, with no annotations, it does not explicitly state whether the tool is read-only, what output format to expect, or any potential side effects, leaving some ambiguity about its behavior.
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, front-loaded with the primary purpose, and lists the checks in a compact list format. No redundant words or unnecessary details.
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 simple, zero-parameter tool with an output schema, the description covers all essential information: what it checks, when to use it, and its relationship to setup. The output schema presumably handles return values, so no further description is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there is no parameter schema to clarify. The description adds context about the tool's purpose, which is sufficient. Baseline of 4 applies as there are no parameters.
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 ('Check') and identifies the exact resource ('system meets requirements for Ollama embeddings'), listing the specific attributes verified. This clearly distinguishes it from sibling setup and status tools by focusing on pre-installation verification.
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?
The description explicitly states 'Use before attempting Ollama setup,' providing direct when-to-use guidance. This differentiates it from the setup and status sibling tools, making the alternative clear.
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:

[![cowork-history MCP server](https://glama.ai/mcp/servers/egoughnour/cowork-history/badges/card.svg)](https://glama.ai/mcp/servers/egoughnour/cowork-history)

Score Badge

Copy to your README.md:

[![cowork-history MCP server](https://glama.ai/mcp/servers/egoughnour/cowork-history/badges/score.svg)](https://glama.ai/mcp/servers/egoughnour/cowork-history)

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/egoughnour/cowork-history'

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