# GitScrum Knowledge MCP for AI Agents AI Agent Connect

> GitScrum Knowledge lets your AI agent access and update your team's notes, wiki pages, and discussions. It turns your project documentation into a live memory bank where your agent can search across all resources, track version history, and stay updated on team decisions.

## Overview
- **Category:** collaboration
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_aYZl75U8HMoTFXDX8n3M42NkJHirirx5iNI2BRUo/ai-agent-connect
- **Tags:** agent-memory, wiki-documentation, team-discussions, knowledge-base, global-search, revision-history, note-taking

## Description

GitScrum Knowledge connects your AI client to your team's collective brain. Instead of your agent losing context between sessions, this Connector lets it store decisions, meeting notes, and technical specs in a structured way. You can build a wiki for permanent documentation or use notes as a sandbox for temporary project context. Because it links to your existing GitScrum workspace, your agent can pull from real-time discussions or search through old user stories and sprints to find exactly what it needs. It's a primary way to keep your agent grounded in your specific project reality without constantly copy-pasting context. When you find this on the Vinkius marketplace, you're getting a way to bridge the gap between personal AI memory and company-wide knowledge. You can have your agent draft a wiki page based on a recent discussion or summarize a folder of architecture notes instantly. This means you no longer have to hunt through dozens of tabs to find a specific requirement or a past decision. Your agent handles the heavy lifting of information retrieval, allowing you to stay in your flow while it checks the latest status of a task or pulls a specific piece of documentation from a nested wiki page. It turns your project history into an active asset that your agent can use to provide more accurate, context-aware answers.

## Tools

### list_channels
Shows all available discussion channels in your project. Use this to see where conversations are happening.

### list_discussions
Pulls a list of all discussions within a project. This helps your agent see the breadth of team talk.

### create_note_folder
Creates a new folder to group notes like meeting logs or ADRs. This keeps your agent's memory organized.

### list_note_folders
Lists all existing note folders for organization. Use this to see how your memory is structured.

### rename_note_folder
Changes the name of an existing note folder. This helps keep your organization tidy.

### channel_messages
Pulls the message history from a specific channel. This provides context for ongoing conversations.

### search_channel_messages
Finds specific text within a discussion channel. Use this to find old decisions made in chat.

### send_message
Lets the agent post updates or findings to a team channel. This keeps your team informed of AI results.

### create_note
Saves a new markdown note to serve as persistent agent memory. Use this to store permanent project facts.

### delete_note
Removes a note from your workspace permanently. Use this to clean up old context.

### list_notes
Retrieves all notes currently in your workspace. This lets your agent see all saved context.

### move_note_to_folder
Places a note into a specific folder for better organization. This helps manage large amounts of memory.

### note_revisions
Shows the history of changes made to a specific note. Use this to see how a decision evolved.

### update_note
Appends new information or edits an existing note. This keeps your agent's memory current.

### get_channel
Fetches the specific details of a discussion channel. This is useful for checking channel settings.

### reply_to_message
Adds a response to a specific message thread. Use this to keep conversations moving.

### create_channel
Sets up a new discussion channel for team communication. This helps organize different project topics.

### toggle_note_share
Changes whether a note is visible to the rest of the team. Use this to publish private notes.

### global_search
Scans all tasks, wiki pages, and discussions for a specific query. This is the fastest way to find info.

### thread_replies
Fetches all replies within a specific message thread. This helps your agent see full conversation depths.

### create_wiki_page
Generates a new wiki page with optional nested hierarchy. Use this to build out your project documentation.

### delete_wiki_page
Deletes a specific wiki page from your project. Use this to remove obsolete documentation.

### get_wiki_page
Pulls the full content of a specific wiki page. This lets your agent read your full project specs.

### list_wiki_pages
Lists all wiki pages available in the project. Use this to see the scope of your documentation.

### restore_wiki_revision
Reverts a wiki page to a previous version. Use this to undo mistakes in your documentation.

### wiki_revisions
Shows the version history for a specific wiki page. This helps track documentation changes over time.

### search_wiki
Searches specifically through your wiki content. Use this to find specific documentation quickly.

### update_wiki_page
Edits the content of an existing wiki page. This allows your agent to keep your docs accurate.

## Prompt Examples

**Prompt:** 
```
Summarize our recent decision on the database migration from the #engineering channel.
```

**Response:** 
```
I've reviewed the messages in the #engineering channel. Here is the summary of the database migration decision:

**Decision:** Move to PostgreSQL 15
**Rationale:** 
* Better support for JSONB
* Improved performance on complex joins
* Team familiarity

**Next Steps:**
* [ ] Update the connection strings
* [ ] Run the migration script on the staging env
* [ ] Notify the frontend team
```

**Prompt:** 
```
Create a new note in the 'Architecture' folder about our switch to event sourcing.
```

**Response:** 
```
I've created a new note for you.

**Note Title:** ADR-014: Event Sourcing for Order Service
**Location:** Architecture folder
**Content:** 
This note outlines the decision to move to an event sourcing model. 

**Key Points:**
* Decouples services
* Provides a perfect audit log
* Requires a shift in how we handle state updates

I've saved this as a markdown note in your workspace.
```

**Prompt:** 
```
Search the wiki and notes for anything related to the new login flow.
```

**Response:** 
```
I found 4 relevant items in your workspace regarding the 'new login flow':

**Wiki Pages:**
* *Authentication Specs* (Full technical details)
* *User Session Management* (Nested page)

**Notes:**
* *Login UI Mockups* (Contains screenshots and flow diagrams)
* *Security Review - Login* (Summary of the last security audit)
```

## Capabilities

### Store persistent project memory
Your agent can save and update notes to keep context across different sessions.

### Build nested wiki hierarchies
Create structured documentation pages that your agent can read and write.

### Query all workspace resources
Search across notes, wiki pages, and discussions in a single request.

### Track knowledge evolution
View and restore previous versions of notes and wiki pages.

### Sync team discussions
Let your agent read channel history or post updates to team threads.

## Use Cases

### Automating wiki updates
After a sprint, ask your agent to summarize the results and use update_wiki_page to refresh your project documentation automatically.

### Onboarding new team members
Have your agent use list_notes and list_discussions to give a new hire a summary of recent project activity and key decisions.

### Mapping out new features
Use create_wiki_page to build a new feature spec and move_note_to_folder to organize it within your architecture docs.

### Tracking thread conversations
Ask your agent to pull thread_replies from a specific discussion to understand the nuances of a technical debate.

### Cross-referencing requirements
Use list_discussions to see what people are saying in chat while checking your wiki for the official requirements.

## Benefits

- Keep your agent's memory current by using create_note to store architectural decisions and meeting summaries.
- Track how your documentation evolves over time with note_revisions and wiki_revisions to see every change.
- Publish your agent's findings to the team instantly by using toggle_note_share to make private notes public.
- Ensure your agent always has the latest specs by using update_note to refine context as the project moves.
- Access full project specifications quickly with get_wiki_page to pull complete content for your agent.
- Maintain a clean workspace by using delete_note to remove old or irrelevant information from your memory.

## How It Works

The bottom line is your agent gets a permanent, searchable memory of your entire project.

1. Subscribe to the GitScrum Knowledge integration via the Vinkius marketplace.
2. Provide your GitScrum API token and company slug to link your workspace.
3. Ask your agent to find, create, or update your documentation in plain language.

## Frequently Asked Questions

**Does GitScrum Knowledge work for my team's wiki?**
Yes, it connects your AI agent to your existing wiki pages so it can read and update them on the fly. This means your agent can help you write documentation or find specs instantly.

**Can my agent remember things between sessions?**
Yes, by using the notes feature, your agent stores persistent memory that stays with your project. It won't forget the decisions you've saved in your workspace.

**How does this help with team communication?**
Your agent can send updates to channels or reply to threads, keeping everyone in the loop. It can also read channel history to provide context for your current tasks.

**Can I search everything at once?**
Yes, the global search tool lets your agent look through notes, wiki pages, and discussions simultaneously. This makes finding information much faster.

**Does it keep a history of changes?**
Yes, it tracks revisions for both notes and wiki pages so you can see how information has evolved over time. You can also revert to previous versions if needed.

**Is it easy to set up?**
You just need your GitScrum API token and company slug to get started. Once connected, your agent has immediate access to your project's knowledge base.

**Can my AI agent use notes as persistent memory across sessions?**
Absolutely — this is a core design goal. Use `create_note` to store decisions, context, or meeting summaries as markdown notes. Organize them into folders with `create_note_folder` and `move_note_to_folder`. Use `toggle_note_share` to publish findings to the team. Every edit is versioned via `note_revisions` so you can track how knowledge evolves.

**Can the agent search across everything in my workspace at once?**
Yes! The `global_search` tool performs a unified search across tasks, wiki pages, discussions, user stories, sprints, and notes. Results are grouped by resource type, so you instantly see where every mention lives. It's the fastest way to find anything in your workspace.

**Can the agent participate in team discussions and reply to threads?**
Yes. Use `send_message` to post updates to any discussion channel, and `reply_to_message` for threaded conversations. The agent can also create channels with `create_channel`, search message history with `search_channel_messages`, and review thread replies with `thread_replies` — enabling fully automated status updates and knowledge sharing.