Skip to content
Back to search

agentic-tools-mcp

A comprehensive Model Context Protocol (MCP) server providing AI assistants with powerful task management and agent memories capabilities with project-specific storage.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/pimzino--agentic-tools-mcp/badge.svg)](/listings/pimzino--agentic-tools-mcp)

HTML

<a href="/listings/pimzino--agentic-tools-mcp"><img src="/api/listings/pimzino--agentic-tools-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Quick Start

npx -y @pimzino/agentic-tools-mcp

Global Installation

npm install -g @pimzino/agentic-tools-mcp

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 533 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Agentic Tools MCP Server
  2. [![npm version](https://badge.fury.io/js/@pimzino%2Fagentic-tools-mcp.svg)](https://badge.fury.io/js/@pimzino%2Fagentic-tools-mcp)
  3. [![npm downloads](https://img.shields.io/npm/dm/@pimzino/agentic-tools-mcp.svg)](https://www.npmjs.com/package/@pimzino/agentic-tools-mcp)
  4. [![GitHub stars](https://img.shields.io/github/stars/Pimzino/agentic-tools-mcp.svg)](https://github.com/Pimzino/agentic-tools-mcp/stargazers)
  5. [![GitHub license](https://img.shields.io/github/license/Pimzino/agentic-tools-mcp.svg)](https://github.com/Pimzino/agentic-tools-mcp/blob/main/LICENSE)
  6. [![Node.js Version](https://img.shields.io/node/v/@pimzino/agentic-tools-mcp.svg)](https://nodejs.org/)
  7. A comprehensive Model Context Protocol (MCP) server providing AI assistants with powerful **advanced task management** and **agent memories** capabilities with **project-specific storage**.
  8. ## 🔗 Ecosystem
  9. This MCP server is part of a complete task and memory management ecosystem:
  10. - **🖥️ [VS Code Extension](https://github.com/Pimzino/agentic-tools-mcp-companion)** - Beautiful GUI interface for managing tasks and memories directly in VS Code
  11. - **⚡ MCP Server** (this repository) - Advanced AI agent tools and API for intelligent task management
  12. > **💡 Pro Tip**: Use both together for the ultimate productivity experience! The VS Code extension provides a visual interface while the MCP server enables AI assistant integration with advanced features like PRD parsing, task recommendations, and research capabilities.
  13. ## Features
  14. ### 🎯 Advanced Task Management System with Unlimited Hierarchy (v1.8.0)
  15. - **Projects**: Organize work into distinct projects with descriptions
  16. - **Unified Task Model**: Single task interface supporting unlimited nesting depth
  17. - **Unlimited Hierarchy**: Tasks → Subtasks → Sub-subtasks → infinite depth nesting
  18. - **Rich Features at All Levels**: Every task gets priority, complexity, dependencies, tags, and time tracking
  19. - **Parent-Child Relationships**: Flexible hierarchy organization with `parentId` field
  20. - **Level Tracking**: Automatic hierarchy level calculation and visual indicators
  21. - **Tree Visualization**: Comprehensive hierarchical tree display with unlimited depth
  22. - **Intelligent Dependencies**: Task dependency management with validation across hierarchy
  23. - **Priority & Complexity**: 1-10 scale prioritization and complexity estimation at every level
  24. - **Enhanced Status Tracking**: pending, in-progress, blocked, done status workflow
  25. - **Tag-Based Organization**: Flexible categorization and filtering
  26. - **Time Tracking**: Estimated and actual hours for project planning
  27. - **Automatic Migration**: Seamless upgrade from old 3-level to unlimited depth model
  28. - **Progress Tracking**: Monitor completion status at all hierarchy levels
  29. - **Project-Specific Storage**: Each working directory has isolated task data
  30. - **Git-Trackable**: Task data can be committed alongside your code
  31. ### 🧠 Agent Memories System
  32. - **Persistent Memory**: Store and retrieve agent memories with titles and detailed content
  33. - **Intelligent Search**: Multi-field text search with relevance scoring across titles, content, and categories
  34. - **Smart Ranking**: Advanced scoring algorithm prioritizes title matches (60%), content matches (30%), and category bonuses (20%)
  35. - **Rich Metadata**: Flexible metadata system for enhanced context
  36. - **JSON Storage**: Individual JSON files organized by category, named after memory titles
  37. - **Project-Specific**: Isolated memory storage per working directory
  38. ### 🔧 MCP Tools Available
  39. #### Project Management
  40. - `list_projects` - View all projects in a working directory
  41. - `create_project` - Create a new project in a working directory
  42. - `get_project` - Get detailed project information
  43. - `update_project` - Edit project name/description
  44. - `delete_project` - Delete project and all associated data
  45. #### Task Management (Unlimited Hierarchy v1.8.0)
  46. - `list_tasks` - View tasks in hierarchical tree format with unlimited depth visualization
  47. - `create_task` - Create tasks at any hierarchy level with `parentId` (supports unlimited nesting)
  48. - `get_task` - Get detailed task information including hierarchy relationships
  49. - `update_task` - Edit tasks, metadata, or move between hierarchy levels with `parentId`
  50. - `delete_task` - Delete task and all child tasks recursively
  51. - `move_task` - Dedicated tool for moving tasks within hierarchy structure
  52. - `migrate_subtasks` - Automatic migration tool for converting legacy subtasks to unified model
  53. #### Advanced Task Management (AI Agent Tools)
  54. - `parse_prd` - Parse Product Requirements Documents and automatically generate structured tasks
  55. - `get_next_task_recommendation` - Get intelligent task recommendations based on dependencies, priorities, and complexity
  56. - `analyze_task_complexity` - Analyze task complexity and suggest breaking down overly complex tasks
  57. - `infer_task_progress` - Analyze codebase to infer task completion status from implementation evidence
  58. - `research_task` - Guide AI agents to perform comprehensive web research with memory integration
  59. - `generate_research_queries` - Generate intelligent, targeted web search queries for task research
  60. #### Legacy Subtask Management (Backward Compatibility)
  61. - `list_subtasks` - View child tasks (legacy compatibility, now uses unified Task model)
  62. - `create_subtask` - Create child tasks (legacy compatibility, creates tasks with `parentId`)
  63. - `get_subtask` - Get task information (legacy compatibility for existing subtasks)
  64. - `update_subtask` - Edit child tasks (legacy compatibility, uses unified Task operations)
  65. - `delete_subtask` - Delete child tasks (legacy compatibility, deletes tasks recursively)
  66. #### Agent Memory Management
  67. - `create_memory` - Store new memories with title and detailed content
  68. - `search_memories` - Find memories using intelligent multi-field search with relevance scoring
  69. - `get_memory` - Get detailed memory information
  70. - `list_memories` - List memories with optional filtering
  71. - `update_memory` - Edit memory title, content, metadata, or categorization
  72. - `delete_memory` - Delete a memory (requires confirmation)
  73. **Important**: All tools require a `workingDirectory` parameter to specify where the data should be stored. This enables project-specific task and memory management.
  74. ## Installation
  75. ### Quick Start
  76. ```bash
  77. npx -y @pimzino/agentic-tools-mcp
  78. ```
  79. ### Global Installation
  80. ```bash
  81. npm install -g @pimzino/agentic-tools-mcp
  82. ```
  83. ## Usage
  84. ### Storage Modes
  85. The MCP server supports two storage modes:
  86. #### 📁 Project-Specific Mode (Default)
  87. Data is stored in `.agentic-tools-mcp/` subdirectories within each project's working directory.
  88. ```bash
  89. npx -y @pimzino/agentic-tools-mcp
  90. ```
  91. #### 🌐 Global Directory Mode
  92. Use the `--claude` flag to store all data in a standardized global directory:
  93. - **Windows**: `C:\Users\{username}\.agentic-tools-mcp\`
  94. - **macOS/Linux**: `~/.agentic-tools-mcp/`
  95. ```bash
  96. npx -y @pimzino/agentic-tools-mcp --claude
  97. ```
  98. **When to use `--claude` flag:**
  99. - With Claude Desktop client (non-project-specific usage)
  100. - When you want a single global workspace for all tasks and memories
  101. - For AI assistants that work across multiple projects
  102. **Note**: When using `--claude` flag, the `workingDirectory` parameter in all tools is ignored and the global directory is used instead.
  103. ### With Claude Desktop
  104. #### Project-Specific Mode (Default)
  105. ```json
  106. {
  107. "mcpServers": {
  108. "agentic-tools": {
  109. "command": "npx",
  110. "args": ["-y", "@pimzino/agentic-tools-mcp"]
  111. }
  112. }
  113. }
  114. ```
  115. #### Global Directory Mode (Recommended for Claude Desktop)
  116. ```json
  117. {
  118. "mcpServers": {
  119. "agentic-tools": {
  120. "command": "npx",
  121. "args": ["-y", "@pimzino/agentic-tools-mcp", "--claude"]
  122. }
  123. }
  124. }
  125. ```
  126. **Note**: The server now includes both task management and agent memories features.
  127. ### With AugmentCode
  128. #### Project-Specific Mode (Default)
  129. 1. Open Augment Settings Panel (gear icon)
  130. 2. Add MCP server:
  131. - **Name**: `agentic-tools`
  132. - **Command**: `npx -y @pimzino/agentic-tools-mcp`
  133. 3. Restart VS Code
  134. #### Global Directory Mode
  135. 1. Open Augment Settings Panel (gear icon)
  136. 2. Add MCP server:
  137. - **Name**: `agentic-tools`
  138. - **Command**: `npx -y @pimzino/agentic-tools-mcp --claude`
  139. 3. Restart VS Code
  140. **Features Available**: Task management, agent memories, and text-based search capabilities.
  141. ### With VS Code Extension (Recommended)
  142. For the best user experience, install the [**Agentic Tools MCP Companion**](https://github.com/Pimzino/agentic-tools-mcp-companion) VS Code extension:
  143. 1. Clone the companion extension repository
  144. 2. Open it in VS Code and press `F5` to run in development mode
  145. 3. Enjoy a beautiful GUI interface for all task and memory management
  146. **Benefits of using both together:**
  147. - 🎯 **Visual Task Management**: Rich forms with priority, complexity, status, tags, and time tracking
  148. - 🎨 **Enhanced UI**: Status emojis, priority badges, and visual indicators
  149. - 🔄 **Real-time Sync**: Changes in VS Code instantly available to AI assistants
  150. - 📁 **Project Integration**: Seamlessly integrated with your workspace
  151. - 🤖 **AI Collaboration**: Human planning with AI execution for optimal productivity
  152. ### With Other MCP Clients
  153. The server uses STDIO transport and can be integrated with any MCP-compatible client:
  154. #### Project-Specific Mode
  155. ```bash
  156. npx -y @pimzino/agentic-tools-mcp
  157. ```
  158. #### Global Directory Mode
  159. ```bash
  160. npx -y @pimzino/agentic-tools-mcp --claude
  161. ```
  162. ## Data Models
  163. ### Project
  164. ```typescript
  165. {
  166. id: string; // Unique identifier
  167. name: string; // Project name
  168. description: string; // Project overview
  169. createdAt: string; // ISO timestamp
  170. updatedAt: string; // ISO timestamp
  171. }
  172. ```
  173. ### Task (Unified Model v1.8.0 - Unlimited Hierarchy)
  174. ```typescript
  175. {
  176. id: string; // Unique identifier
  177. name: string; // Task name
  178. details: string; // Enhanced description
  179. projectId: string; // Parent project reference
  180. completed: boolean; // Completion status
  181. createdAt: string; // ISO timestamp
  182. updatedAt: string; // ISO timestamp
  183. // Unlimited hierarchy fields (v1.8.0)
  184. parentId?: string; // Parent task ID for unlimited nesting (NEW)
  185. level?: number; // Computed hierarchy level (0, 1, 2, etc.) (NEW)
  186. // Enhanced metadata fields (from v1.7.0)
  187. dependsOn?: string[]; // Task dependencies (IDs of prerequisite tasks)
  188. priority?: number; // Priority level (1-10, where 10 is highest)
  189. complexity?: number; // Complexity estimate (1-10, where 10 is most complex)
  190. status?: string; // Enhanced status: 'pending' | 'in-progress' | 'blocked' | 'done'
  191. tags?: string[]; // Tags for categorization and filtering
  192. estimatedHours?: number; // Estimated time to complete (hours)
  193. actualHours?: number; // Actual time spent (hours)
  194. }
  195. ```
  196. ### Legacy Subtask (Deprecated in v1.8.0)
  197. The separate Subtask interface has been replaced by the unified Task model. Legacy subtasks are automatically migrated to tasks with `parentId` field. This ensures unlimited hierarchy depth while maintaining all rich features at every level.
  198. ### Memory
  199. ```typescript
  200. {
  201. id: string; // Unique identifier
  202. title: string; // Short title for file naming (max 50 characters)
  203. content: string; // Detailed memory content/text (no limit)
  204. metadata: Record<string, any>; // Flexible metadata object
  205. createdAt: string; // ISO timestamp
  206. updatedAt: string; // ISO timestamp
  207. category?: string; // Optional categorization
  208. }
  209. ```
  210. ## Example Workflow
  211. 1. **Create a Project**
  212. ```
  213. Use create_project with:
  214. - workingDirectory="/path/to/your/project"
  215. - name="Website Redesign"
  216. - description="Complete overhaul of company website"
  217. ```
  218. 2. **Add Enhanced Tasks**
  219. ```
  220. Use create_task with:
  221. - workingDirectory="/path/to/your/project"
  222. - name="Design mockups"
  223. - details="Create wireframes and high-fidelity designs"
  224. - projectId="[project-id-from-step-1]"
  225. - priority=8 (high priority)
  226. - complexity=6 (above average complexity)
  227. - status="pending"
  228. - tags=["design", "ui", "mockups"]
  229. - estimatedHours=16
  230. ```
  231. 3. **Break Down Tasks**
  232. ```
  233. Use create_subtask with:
  234. - workingDirectory="/path/to/your/project"
  235. - name="Create wireframes"
  236. - details="Sketch basic layout structure"
  237. - taskId="[task-id-from-step-2]"
  238. ```
  239. 4. **Track Progress**
  240. ```
  241. Use update_task and update_subtask to mark items as completed
  242. Use list_projects, list_tasks, and list_subtasks to view progress
  243. (All with workingDirectory parameter)
  244. ```
  245. ### Agent Memories Workflow
  246. 1. **Create a Memory**
  247. ```
  248. Use create_memory with:
  249. - workingDirectory="/path/to/your/project"
  250. - title="User prefers concise technical responses"
  251. - content="The user has explicitly stated they prefer concise responses with technical explanations. They value brevity but want detailed technical information when relevant."
  252. - metadata={"source": "conversation", "confidence": 0.9}
  253. - category="user_preferences"
  254. ```
  255. 2. **Search Memories**
  256. ```
  257. Use search_memories with:
  258. - workingDirectory="/path/to/your/project"
  259. - query="user preferences responses"
  260. - limit=5
  261. - threshold=0.3
  262. - category="user_preferences"
  263. ```
  264. 3. **List and Manage**
  265. ```
  266. Use list_memories to view all memories
  267. Use update_memory to modify existing memories (title, content, metadata, category)
  268. Use delete_memory to remove outdated memories
  269. (All with workingDirectory parameter)
  270. ```
  271. **📖 Quick Start**: See [docs/QUICK_START_MEMORIES.md](docs/QUICK_START_MEMORIES.md) for a step-by-step guide to agent memories.
  272. ## Data Storage
  273. - **Project-specific**: Each working directory has its own isolated task and memory data
  274. - **File-based**: Task data stored in `.agentic-tools-mcp/tasks/`, memory data in `.agentic-tools-mcp/memories/`
  275. - **Git-trackable**: All data can be committed alongside your project code
  276. - **Persistent**: All data persists between server restarts
  277. - **Atomic**: All operations are atomic to prevent data corruption
  278. - **JSON Storage**: Simple file-based storage for efficient memory organization
  279. - **Backup-friendly**: Simple file-based storage for easy backup and migration
  280. ### Storage Structure
  281. ```
  282. your-project/
  283. ├── .agentic-tools-mcp/
  284. │ ├── tasks/ # Task management data for this project
  285. │ │ └── tasks.json # Projects, tasks, and subtasks data
  286. │ └── memories/ # JSON file storage for memories
  287. │ ├── preferences/ # User preferences category
  288. │ │ └── User_prefers_concise_technical_responses.json
  289. │ ├── technical/ # Technical information category
  290. │ │ └── React_TypeScript_project_with_strict_ESLint.json
  291. │ └── context/ # Context information category
  292. │ └── User_works_in_healthcare_needs_HIPAA_compliance.json
  293. ├── src/
  294. ├── package.json
  295. └── README.md
  296. ```
  297. ### Working Directory Parameter
  298. All MCP tools require a `workingDirectory` parameter that specifies:
  299. - Where to store the `.agentic-tools-mcp/` folder (in project-specific mode)
  300. - Which project's task and memory data to access
  301. - Enables multiple projects to have separate task lists and memory stores
  302. **Note**: When the server is started with the `--claude` flag, the `workingDirectory` parameter is ignored and a global user directory is used instead (`~/.agentic-tools-mcp/` on macOS/Linux or `C:\Users\{username}\.agentic-tools-mcp\` on Windows).
  303. ### Benefits of Project-Specific Storage
  304. - **Git Integration**: Task and memory data can be committed with your code
  305. - **Team Collaboration**: Share task lists and agent memories via version control
  306. - **Project Isolation**: Each project has its own task management and memory system
  307. - **Multi-Project Workflow**: Work on multiple projects simultaneously with isolated memories
  308. - **Backup & Migration**: File-based storage travels with your code
  309. - **Text Search**: Simple content-based memory search for intelligent context retrieval
  310. - **Agent Continuity**: Persistent agent memories across sessions and deployments
  311. ## Error Handling
  312. - **Validation**: All inputs are validated with comprehensive error messages
  313. - **Directory Validation**: Ensures working directory exists and is accessible
  314. - **Referential Integrity**: Prevents orphaned tasks/subtasks with cascade deletes
  315. - **Unique Names**: Enforces unique names within scope (project/task)
  316. - **Confirmation**: Destructive operations require explicit confirmation
  317. - **Graceful Degradation**: Detailed error messages for troubleshooting
  318. - **Storage Errors**: Clear messages when storage initialization fails
  319. ## Development
  320. ### Building from Source
  321. ```bash
  322. git clone <repository>
  323. cd agentic-tools-mcp
  324. npm install
  325. npm run build
  326. npm start
  327. ```
  328. ### Project Structure
  329. ```
  330. src/
  331. ├── features/
  332. │ ├── task-management/
  333. │ │ ├── tools/ # MCP tool implementations
  334. │ │ │ ├── projects/ # Project CRUD operations
  335. │ │ │ ├── tasks/ # Task CRUD operations
  336. │ │ │ └── subtasks/ # Subtask CRUD operations
  337. │ │ ├── models/ # TypeScript interfaces
  338. │ │ └── storage/ # Data persistence layer
  339. │ └── agent-memories/
  340. │ ├── tools/ # Memory MCP tool implementations
  341. │ │ └── memories/ # Memory CRUD operations
  342. │ ├── models/ # Memory TypeScript interfaces
  343. │ └── storage/ # JSON file storage implementation
  344. ├── server.ts # MCP server configuration
  345. └── index.ts # Entry point
  346. ```
  347. ## Troubleshooting
  348. ### Common Issues
  349. **"Working directory does not exist"**
  350. - Ensure the path exists and is accessible
  351. - Use absolute paths for reliability
  352. - Check directory permissions
  353. **"Text search returns no results"** (Agent Memories)
  354. - Try using different keywords or phrases
  355. - Check that memories contain the search terms
  356. - Verify that the query content matches memory content
  357. **"Memory files not found"** (Agent Memories)
  358. - Ensure the working directory exists and is writable
  359. - Check that the .agentic-tools-mcp/memories directory was created
  360. ## Version History
  361. See [CHANGELOG.md](CHANGELOG.md) for detailed version history and release notes.
  362. ### Current Version: 1.8.0
  363. - 🚀 **NEW: Unified Task Model**: Single task interface supporting unlimited nesting depth
  364. - 🚀 **NEW: Unlimited Hierarchy**: Tasks → Subtasks → Sub-subtasks → infinite depth nesting
  365. - 🚀 **NEW: Automatic Migration**: Seamless upgrade from 3-level to unlimited depth model
  366. - 🚀 **NEW: Enhanced Tree Display**: Hierarchical visualization with level indicators and unlimited depth
  367. - 🚀 **NEW: Hierarchy Tools**: `move_task`, `migrate_subtasks` for unlimited depth management
  368. - ✅ **Rich Features at All Levels**: Every task gets priority, complexity, dependencies, tags, and time tracking
  369. - ✅ **Enhanced Task Management**: Rich metadata with dependencies, priority, complexity, status, tags, and time tracking
  370. - ✅ **Advanced AI Agent Tools**: PRD parsing, task recommendations, complexity analysis, progress inference, and research guidance
  371. - ✅ **Intelligent Task Dependencies**: Dependency validation and workflow management across hierarchy
  372. - ✅ **Priority & Complexity System**: 1-10 scale prioritization and complexity estimation at every level
  373. - ✅ **Enhanced Status Workflow**: pending → in-progress → blocked → done status tracking
  374. - ✅ **Tag-Based Organization**: Flexible categorization and filtering system
  375. - ✅ **Time Tracking**: Estimated and actual hours for project planning
  376. - ✅ **Hybrid Research Integration**: Web research with memory caching for AI agents
  377. - ✅ **Complete task management system** with unlimited hierarchical organization
  378. - ✅ **Agent memories** with title/content architecture and JSON file storage
  379. - ✅ **Intelligent multi-field search** with relevance scoring
  380. - ✅ **Project-specific storage** with comprehensive MCP tools
  381. - ✅ **Global directory mode** with --claude flag for Claude Desktop
  382. - ✅ **VS Code extension ecosystem** integration
  383. ## Acknowledgments
  384. We're grateful to the open-source community and the following projects that make this MCP server possible:
  385. ### Core Technologies
  386. - **[@modelcontextprotocol/sdk](https://github.com/modelcontextprotocol/typescript-sdk)** - The foundation for MCP server implementation
  387. - **[Node.js File System](https://nodejs.org/api/fs.html)** - Reliable file-based storage for memory persistence
  388. - **[TypeScript](https://www.typescriptlang.org/)** - Type-safe JavaScript development
  389. - **[Node.js](https://nodejs.org/)** - JavaScript runtime environment
  390. ### Development & Validation
  391. - **[Zod](https://zod.dev/)** - TypeScript-first schema validation for robust input handling
  392. - **[ESLint](https://eslint.org/)** - Code quality and consistency
  393. - **[Prettier](https://prettier.io/)** - Code formatting
  394. ### File Storage & Search
  395. - **JSON** - Simple, human-readable data format for memory storage
  396. - **Text Search** - Efficient content-based search across memory files
  397. ### Special Thanks
  398. - **Open Source Community** - For creating the tools and libraries that make this project possible
  399. ## License
  400. MIT License - see LICENSE file for details.
  401. ## Contributing
  402. Contributions are welcome! Please feel free to submit issues and pull requests.
  403. ### Development Setup
  404. ```bash
  405. git clone <repository>
  406. cd agentic-tools-mcp
  407. npm install
  408. npm run build
  409. npm start
  410. ```
  411. ## Related Projects
  412. ### 🖥️ VS Code Extension
  413. **[Agentic Tools MCP Companion](https://github.com/Pimzino/agentic-tools-mcp-companion)** - A beautiful VS Code extension that provides a GUI interface for this MCP server.
  414. **Key Features:**
  415. - 🎯 **Visual Task Management**: Rich GUI with enhanced task metadata forms
  416. - 📝 **Enhanced Forms**: Priority, complexity, status, tags, and time tracking
  417. - 🎨 **Visual Indicators**: Status emojis, priority badges, and complexity indicators
  418. - 📊 **Rich Tooltips**: Complete task information on hover
  419. - 🔄 **Real-time Sync**: Instant synchronization with MCP server data
  420. - � **Responsive Design**: Adaptive forms that work on different screen sizes
  421. **Perfect for:**
  422. - Visual task management and planning
  423. - Teams who prefer GUI interfaces
  424. - Project managers who need rich task metadata
  425. - Anyone who wants beautiful task organization in VS Code
  426. ## Support
  427. For issues and questions, please use the GitHub issue tracker.
  428. ### Documentation
  429. - 📖 **[API Reference](docs/API_REFERENCE.md)** - Complete tool documentation
  430. - 🧠 **[Agent Memories Guide](docs/AGENT_MEMORIES.md)** - Comprehensive memory system guide
  431. - 🚀 **[Quick Start: Memories](docs/QUICK_START_MEMORIES.md)** - Get started with agent memories
  432. - 📋 **[Changelog](CHANGELOG.md)** - Version history and release notes
  433. ### Getting Help
  434. - 🐛 Report bugs via GitHub issues
  435. - 💡 Request features via GitHub discussions
  436. - 🖥️ **VS Code Extension Issues**: Report extension-specific issues at [agentic-tools-mcp-companion](https://github.com/Pimzino/agentic-tools-mcp-companion/issues)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.