> ## Documentation Index
> Fetch the complete documentation index at: https://helpcenter.magure.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Tools overview
> Connect your AI agents to external tools and services through the Model Context Protocol
## How tools work in MagOneAI
MagOneAI agents connect to external services through **MCP (Model Context Protocol)**, Anthropic's open standard for AI-tool communication. Instead of building proprietary integrations, MagOneAI adopted MCP to ensure your agents can work with any MCP-compatible tool — now and in the future.
When an agent needs to take action in the real world — schedule a meeting, send an email, query a database, or search the web — it calls a tool. The platform handles authentication, execution, and response handling, so your agents can focus on reasoning and decision-making.
## MCP architecture overview
The Model Context Protocol defines a standardized way for AI agents to discover and interact with external tools:
* **MCP servers** expose tools and resources to agents
* **MagOneAI** connects to MCP servers as a client on behalf of your agents
* **Each tool** has defined parameters and return types using JSON Schema
* **Agents** discover available tools and call them during reasoning loops
This architecture means you're not locked into a proprietary tool ecosystem. Tools built for MagOneAI work with any MCP client, and tools built for other MCP clients work with MagOneAI.
```mermaid theme={null}
graph LR
A[Agent] --> B[MagOneAI Platform]
B --> C[MCP Server: Google]
B --> D[MCP Server: Microsoft]
B --> E[MCP Server: Database]
B --> F[MCP Server: Custom API]
```
## Built-in tools
MagOneAI includes ready-to-use integrations with popular services. Enable them in your project settings and connect your accounts.
Schedule meetings, send emails, and manage your Google Workspace from agents.
Connect to Microsoft 365 for calendar management and email automation.
Give agents access to real-time information from the web.
Query PostgreSQL, MySQL, and MongoDB, read-only, from agents.
### Full built-in catalog
Each integration is an MCP server the platform ships and manages. Enable the ones your project needs and connect credentials once. Authentication is handled the way each service expects: an OAuth sign-in, an API key, a connection string, or nothing at all.
| Integration | What it does | Authentication |
| --------------------- | --------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
| **web-search** | Multi-provider web search (DuckDuckGo, Tavily, Google Serper, Google CSE, Parallel AI). DuckDuckGo works with no key. | API key, optional per provider |
| **outlook-email** | Send, read, and manage Outlook emails via Microsoft Graph. | OAuth2 (Microsoft) |
| **outlook-calendar** | Create, update, and list Outlook calendar events via Microsoft Graph. | OAuth2 (Microsoft) |
| **google-calendar** | List, create, and delete Google Calendar events. | OAuth2 (Google) |
| **google-gmail** | List, read, and send emails via Gmail. | OAuth2 (Google) |
| **filesystem** | Read and write files on the server with path-based access control. | Allowed paths |
| **onedrive** | Browse, upload, and download OneDrive files with content extraction. | OAuth2 (Microsoft) + allowed paths |
| **database** | Query PostgreSQL, MySQL, or MongoDB. Read-only: destructive SQL is blocked. | Connection string |
| **vanna** | Natural-language to SQL using Vanna.AI with a vector store. | API keys |
| **file-tools** | Extract data from CSV, Excel, and PDF files; export results as Excel. | Pre-configured by admin |
| **csv-to-sql** | Import CSV files into PostgreSQL with automatic type inference. | Pre-configured by admin |
| **checkbox-detector** | Detect checked and unchecked boxes in scanned forms using template matching. | Pre-configured by admin |
The **database** integration is read-only across PostgreSQL, MySQL, and MongoDB, and a single workspace can configure more than one connection. See [Database tools](/tools/database-tools) for details.
## Built-in agent tools
Beyond MCP integrations, an [Agent node](/workflows/agent-node) can be given a set of **system tools** that need no connection or credentials. You select which ones an agent gets in its capabilities:
* **get\_current\_time** — the current date and time, so an agent reasons against "now" instead of guessing.
* **calculator** — deterministic arithmetic, so numbers come from a real calculation rather than the model's estimate.
* **File tools** — `read`, `write`, `edit`, `glob`, and `grep` for working with files an agent has access to (for example, an uploaded document): find files, read them (PDF/DOCX/Excel text is pre-extracted automatically), search inside them, and write or edit file contents.
These are enabled per agent, so you grant only what a given agent should be able to do.
## Requesting a new integration
If the integration you need isn't in the built-in catalog yet, use the **Request an integration** form on the MCP Tools page. The request reaches the platform team as an integration request, so they can prioritize adding it. In the meantime, you can often cover the gap yourself with a [custom MCP tool](/tools/custom-tools) or the [API node](/workflows/api-node).
## Custom tools
Beyond built-in integrations, you can add any MCP-compatible tool server to MagOneAI. Connect your internal APIs, proprietary systems, or third-party services:
* Build an MCP server using Python or TypeScript SDKs
* Wrap any REST API with tool definitions
* Register the server in your project settings
* Agents can now call your custom tools
Learn more in the [Custom MCP tools](/tools/custom-tools) guide.
## OAuth flow management
For tools that require user authentication (Google, Microsoft), MagOneAI handles the entire OAuth flow:
Add your OAuth client ID and secret in the Admin Portal. These are stored securely in HashiCorp Vault.
When a user first uses a tool, they complete the OAuth consent flow in their browser.
MagOneAI stores access tokens and refresh tokens in Vault. Token refresh happens automatically — users never see expired credentials.
Credentials are injected at runtime when agents execute tools. No credentials in logs or configurations.
Users authenticate once per service. After that, agents can use those tools on the user's behalf without re-authentication.
## Tool execution in workflows
You can use tools in two ways within your workflows:
### Via Agent nodes
When you attach tools to an agent, the agent decides when and how to call them based on its reasoning. This is **non-deterministic** — the agent chooses which tools to use and with what parameters.
**Example:** An agent node with system prompt "Schedule a meeting with the client based on their availability" will:
1. Check the client's calendar using the calendar tool
2. Find available time slots
3. Create a calendar event with appropriate details
### Via Tool nodes
Tool nodes execute a specific tool with specified parameters. This is **deterministic** — you control exactly which tool runs and when.
**Example:** A Tool node configured to "Send email to [john@example.com](mailto:john@example.com) with subject 'Weekly Report' and body from variable `report_content`" will always send that exact email.
Use Agent nodes for intelligence and flexibility. Use Tool nodes for guaranteed execution of specific actions.
## Security and credentials
All credentials are stored in **HashiCorp Vault**:
* **API keys** for platform-level integrations (OpenAI, Anthropic, etc.)
* **OAuth tokens** for user-authenticated services (Google, Microsoft)
* **Database connection strings** for SQL tools
* **Custom integration secrets** for your internal APIs
Credentials are never exposed in:
* Workflow configurations
* Agent logs or traces
* API responses
* User interfaces
They're injected at runtime only when needed, then immediately discarded from memory.
**MCP (Model Context Protocol) is Anthropic's open standard for AI-tool communication.** MagOneAI adopted MCP to ensure interoperability and avoid proprietary tool formats. Tools you build today will work with the AI ecosystem of tomorrow.
## Next steps
Understand how the Model Context Protocol works under the hood
Build your own MCP tools for internal systems