How To Create Upgraded AI Agents with Gram

Key Concepts

• MCP (Multi-Chain Protocol): A framework or system that allows AI agents to connect to and utilize multiple APIs.
• Graham: Speak Easy's platform for building customizable MCPs.
• API (Application Programming Interface): A set of rules and protocols that allows different software applications to communicate with each other.
• Ampify: A platform that provides access to various APIs, such as YouTube scrapers and website crawlers.
• OpenAPI Definition: A standard format for describing RESTful APIs, often provided as a JSON or YAML file.
• JSON (JavaScript Object Notation): A lightweight data-interchange format.
• YAML (YAML Ain't Markup Language): A human-readable data-serialization language.
• Environment Variables: Variables that store configuration settings, such as API keys, for an application or service.
• Cursor AI: An AI-powered code editor that can integrate with MCPs.
• Custom Tools: Within Graham, the ability to combine multiple API actions into a single, callable tool.

Upgrading AI Agents with Customizable MCPs via Graham

This video demonstrates how to enhance AI agents by creating Multi-Chain Protocols (MCPs) that can connect to any API on the internet, using Speak Easy's new platform, Graham. Graham allows for the creation of fully customizable MCPs by integrating various API blocks into a cohesive toolkit for AI agents, usable in platforms like Cursor AI and ChatGPT.

Setting Up an MCP Server

The process begins with setting up an MCP server.

1. API Selection: The first step involves choosing which API to connect to. The video highlights Ampify as a resource for finding various APIs, such as Google Map scrapers, website content crawlers, and Facebook ad library scrapers. For this demonstration, the YouTube scraper API from Ampify and Bumbo's API are selected.
2. Obtaining API Specifications: To integrate an API, its specification is required. This is typically found by accessing the "OpenAPI definition" on the API provider's platform (e.g., Ampify). This definition, usually in JSON or YAML format, outlines all the specific actions the API can perform (e.g., grabbing a video title, duration, or thumbnail data).
3. Downloading and Uploading Specifications: The OpenAPI definition file is downloaded. The video shows a method of using Cursor AI to convert the API specs into a downloadable JSON file. This JSON file is then uploaded to Graham. Graham accepts .yml, .yaml, .yml., and .json formats.
4. Naming and Configuring the MCP: The uploaded API is given a specific name (e.g., "YouTube scraper"). Graham then identifies the relevant actions (tools) from the API. These actions can be renamed for clarity and to define a "slug" for referencing the MCP. The video demonstrates creating a multi-layer MCP named "YouTube grab" that combines the YouTube scraper and Bumbo's API.

Integrating Multiple APIs

The process extends to integrating additional APIs into the MCP.

1. Adding Bumbo's API: The same process of obtaining the OpenAPI definition (JSON or YAML) from Bumbo's documentation is followed. This specification is then uploaded to Graham.
2. Adding Tools to the MCP Server: Once APIs are added as separate toolsets, their individual tools can be added to the main MCP server (e.g., "YouTube scraper"). This involves selecting the desired tools from the newly added API (e.g., Bumbo's "create chat" tool).
3. Environment Variables: Some APIs, like Bumbo's, require API keys for authentication. These are configured as environment variables within Graham. For Bumbo's API, an API key is needed, similar to OpenAI or Claude API keys. This is set up under "Environments" by creating a new environment, assigning it to the relevant toolset, and filling in the required variables, such as the "bumpups API key." The video notes that server URLs can often be left blank.

Testing and Configuring the MCP

Graham provides tools for testing and refining the MCP.

1. Playground Testing: The "Playground" feature in Graham allows users to test the integrated tools. By selecting the MCP toolset and an environment, users can execute specific API actions. For example, the video demonstrates using Bumbo's "create chat" tool to ask a question about a specific YouTube video.
2. Action Configuration: Within the MCP server settings, users can configure individual actions. This includes editing the description of a tool, which can be read by AI models to guide their usage. For instance, the description for "create chat" can be enhanced with instructions like "Provide the video URL and an optimal prompt. If no prompt is provided, the API returns a summary of the video content," or adding constraints like "all responses should be under four sentences."

MCP Installation and Usage

The created MCP can be integrated into other AI platforms.

1. MCP Server Link: Each MCP server has a unique hosted URL (e.g., Web Cafe AI YouTube grab). This URL is crucial for integration.
2. Visibility Settings: Users can choose whether their MCP is publicly available or private (internal-facing).
3. Integration with Cursor AI: Graham offers plug-and-play installation options for various platforms. For Cursor AI, the process involves adding a client, naming it, and providing the MCP's hosted URL as an environment variable. The video provides troubleshooting tips, emphasizing the importance of the correct hosted URL and ensuring environment variables are correctly set.
4. Enabling Specific Tools: When integrating an MCP into a platform like Cursor AI, users can select which specific tools from the MCP they want to enable. For example, enabling only the "create chat" and "get data" tools from the YouTube scraper MCP.

Creating Custom Tools with Graham

A powerful feature of Graham is the ability to create custom tools by combining multiple API actions.

1. Defining Custom Tool Logic: Users can define a custom tool using natural language dictation. For example, "I want you to scrape the YouTube link I provide and output the metadata of the video. Then use pop-up chat to ask for a summary of the video."
2. Toolify and Renaming: Graham "toolifies" this description, creating a new, single callable tool within the MCP. This custom tool can then be renamed (e.g., "YouTube yes").
3. Testing Custom Tools: The custom tool can be tested directly within Graham by providing the necessary input (e.g., a YouTube link). The video demonstrates this, showing how the custom tool successfully retrieves both video metadata and a summary from Bumbo's chat.
4. Chaining API Actions: This custom tool functionality allows for chaining multiple API actions together, enabling complex workflows. For instance, an action from an Instagram scraper could be paired with a TikTok scraper, all executed with a single command within a custom MCP.

Conclusion and Future Potential

The video concludes by emphasizing the intuitive nature of Graham and its support for various programming languages (Python, TypeScript, Java). The core takeaway is that Graham empowers users to create highly customizable MCP servers that can perform virtually any desired action by connecting to any API on the internet, significantly enhancing the capabilities of AI agents. The ability to create custom tools by chaining different API functionalities is highlighted as a key feature for unlocking advanced AI workflows.