Sync open source content 🐝 (from f58726cbcef363def3a18443a16a24dfe32e5636)

Author: beezythebot

docs/gram/introduction.md

@@ -1,95 +1,77 @@
 ---
 title: Introducing Gram 👋
-description: Gram effortlessly turns API specifications and code into LLM-ready tools, generating optimized tool definitions from OpenAPI documents and Gram Functions for powerful agentic workflows.
+description: Gram is the complete MCP cloud. Create and curate high quality agentic tools. Start with your APIs or from scratch with easy to define TypeScript functions. Deploy and host your MCP servers in minutes - secure, authenticated and ready to scale usage.
 sidebar:
   order: 0
 ---
 
-**[Gram](/product/gram)** is the fastest way to build a production-ready MCP server.
+![Gram banner](/assets/docs/gram/img/gram.gif)
 
-It is a platform that enables any company to **create, curate and host** agentic tools for your APIs.
+**[Gram](/product/gram)** is the complete MCP cloud. Create and curate high quality agentic tools. Deploy and host your MCP servers in minutes. Secure, complete with OAuth and ready to scale in for production usage.
 
-## Why MCP Matters
+The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) provides a standardized way to connect LLMs to tools and data. Gram provides a serverless and production ready platform to build and host tools as MCP servers. Source tools through existing APIs or build from scratch using TypeScript functions. Mix and match tools in toolsets and expose them as MCP servers in minutes.
 
-Agents mainly interact with APIs through the [Model Context Protocol (MCP)](/mcp). Since it was announced by Anthropic in November 2024, MCP has seen an unprecedented rate of adoption, quickly becoming the de facto standard. Companies like Microsoft, Google, OpenAI, and Cloudflare (among many others) have embraced it and offer MCP servers as a new way to interact with their existing APIs.
+```typescript filename="gram.ts"
+import { Gram } from "@gram-ai/functions";
+import * as z from "zod/mini";
 
-But creating, deploying, hosting, and managing MCP servers remains confusing and challenging. Although MCP follows a familiar client-server model, it creates confusion about who should build, own, manage, and maintain the server. With APIs, it's always been clear. The producer (like Stripe) hosts the API, and the consumer (for example, an online shop) uses that API. With MCP, hosting models vary: Developers often "host" MCP servers on their own machines, or companies host them internally for team-wide access to third-party integrations.
+const gram = new Gram().tool({
+  name: "greet",
+  description: "Greet someone special",
+  inputSchema: { name: z.string() },
+  async execute(ctx, input) {
+    return ctx.text(`Hello, ${input.name}!`);
+  },
+});
 
-We think that companies will naturally gravitate to hosting and managing their own MCP servers, and we built Gram to make that easy.
-
-## Why Gram?
+export default gram;
+```
 
-To unlock the value of MCP companies need to be able to leverage existing APIs and products capabilities. Gram is aimed to give you a comprehensive experience around MCP without the need to learn a new language or framework. APIs alone are often not enough to build high quality tools but they can be a great starting point to build on.
+Use Gram to build out MCP servers for your product, power chat expereinces in your product or surface the right data to AI agents to automate workflows.
 
-To realise this vision Gram is built with the following principles:
-
-🔹 Simplicity: Easy to use, easy to understand, easy to maintain.
-
-🔹 Performant: Fast infrastructure that you can rely on.
-
-🔹 Secure: Built in security and best practices for working with agentic tools.
-
-🔹 Works with your stack: Helps you leverage existing APIs to bootstrap tools.
+## Why MCP?
 
-Gram is made with love ❤️ and ⚒️ by our [team](/company).
+LLMs and Agents need access to context specific data to perform useful tasks. This data is often found behind an authenticated service, in a database or stored content. [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) is the standard protocol for defining tools that AI can use to connect to external systems where this data may live.
 
-### Create and curate tools with ease
+Since it was announced by Anthropic in November 2024, MCP has seen an unprecedented rate of adoption, quickly becoming the de facto standard. Companies like Microsoft, Google, OpenAI, and Cloudflare (among many others) have embraced it and offer MCP servers as a new way to interact with their products and APIs.
 
-A great MCP server is not a 1:1 mapping to your REST API.
+But creating, deploying, hosting, and managing the lifecycle of MCP servers remains confusing and challenging. Although MCP follows a familiar client-server model, it creates confusion about who should build, own, manage, and maintain the server. With APIs, it's always been clear. The producer (like Stripe) hosts the API, and the consumer (for example, an online shop) uses that API. With MCP, hosting models vary: Developers often "host" MCP servers on their own machines, or companies host them internally for team-wide access to internal apis or third-party integrations..
 
-Existing REST APIs are a starting point, but to create a functional MCP server, you need to perform additional steps:
-
-1. **Scope tools** - Presented with the list of all the operations in an API, LLMs struggle to choose the right tool to accomplish a job. This is due to their limited context window. To improve performance, scope the API operations to only include the most relevant ones. Less is more when it comes to MCP. Gram gives you the ability to create toolsets to scope and slice up your API specs.
-2. **Add Context** - A user reading an API reference is coming in with some implicit context about the relevant business domain. The same is not true of an LLM examining a list of tools on an MCP server. It is up to the MCP server maintainer to make sure the server provides the LLM with the context it needs. Adding rich tool descriptions, prompts, and examples, greatly improves the performance of the MCP server. Focus on the _when_ and _why_ of the tool. Gram gives you the ability to add additional context to your tools.
-3. **Define Custom Tools** - REST APIs are resource-oriented: create a company, update the contact field, etc. MCP servers work best when they're workflow-based: "summarize recent channel activity". Gram gives you the ability to distribute custom tools that wrap multiple API endpoints and additional steps as a single tool.
-
-Gram makes tool creation & curation easy. [Tools](/docs/gram/concepts/tool-definitions) are bootstrapped from [sources](/docs/gram/concepts/tool-sources) like OpenAPI documents (which provide API paths, input schemas, security schemes, and descriptions) or Gram Functions (custom Node.js code). Once a source is uploaded to the Gram platform the day 0 workflow looks like this:
-
-* Remove unnecessary tools from your toolset
-* Combine tools into use case specific toolsets.
-* Fine-tune individual tools with better descriptions and custom prompts
-* Create custom toolsets to map a workflow
-* Test and iterate on tools in the LLM playground
-
-All the changes made to a toolset are reflected in a MCP server instantly.
+We think that companies will naturally gravitate to hosting and managing their own MCP servers, and we built Gram to make that easy.
 
-### Going live: Distributing MCP servers
+## Why Gram?
 
-![MCP server models](/assets/docs/gram/img/blog/the-easiest-way-to-host-mcp-servers/managed-mcp.png)
+Gram is aimed to give you a comprehensive experience and unlock the value of MCP without the need to build complete servers.
 
-People use MCP in various ways, broadly categorized as follows:
+To realise this vision Gram is built with the following principles:
 
-* **Local:** A developer downloads an MCP server to their developer machine, and configures an MCP client, like Claude or Cursor, to use the tools provided in that server.
-* **Remote:** A system administrator downloads an MCP server to a company-accessible server. Anyone at the company can configure their MCP client to interact with a company-accessible tool via this server.
-* **Managed:** The API **producer** hosts and manages the MCP server, allowing any of its customers to configure their MCP clients to connect to the server and use the API.
+🔹 Simplicity: Easy to use, easy to understand, easy to maintain.
 
-Currently, MCP servers are mostly **local** (hosted by API consumers), which creates friction through replicated setup work and lack of centralized control. We believe the industry will evolve toward **Managed** MCP servers, where API producers handle hosting, security, and enterprise features.
+🔹 Performant and Managed: Fast and serverless infrastructure that you can rely on.
 
-### Gram's managed hosting approach
+🔹 Secure: Built in security and best practices for working with agentic tools.
 
-Once tools have been curated, the MCP server is ready to deploy. Every toolset automatically comes with an MCP server hosted at a Gram managed URL. Custom domains can be linked to create a branded, 1st party MCP server at `mcp.{{your-domain}}.com/{{server-name}}`
+🔹 Works with your stack: Helps you leverage existing APIs to bootstrap tools.
 
-Gram provides completely [managed hosting of MCP servers](/docs/gram/getting-started) or self-hosted.
+Gram is made with love ❤️ and ⚒️ by the team at [Speakeasy](/company).
 
-<!-- ## LLM-Friendly Docs
+## LLM-Friendly Docs
 
 This documentation site is also available in [llms.txt](https://llmstxt.org/) format, which is a simple markdown standard that LLMs can consume easily.
 
 The `llms.txt` references two ways to access the LLM-friendly documentation:
-* `llms-small.txt` is an abridged developer documentation for the site.
-* `llms-full.txt` contains the entire documentation. Note this may exceed the context window of your LLM.
 
-In addition, any page can be accessed as markdown by appending .md to the URL. For example, this page would become `https://docs.getgram.ai/introduction.md` , which you can view [here](https://docs.getgram.ai/introduction.md).
+- `llms-small.txt` is an abridged developer documentation for the site.
+- `llms-full.txt` contains the entire documentation. Note this may exceed the context window of your LLM.
 
-Finally, you can copy the contents of any page as markdown by pressing “Cmd+C” (or “Ctrl+C” on Windows) on your keyboard. -->
+In addition, any page can be copied into markdown or opened into popular LLM chat clients like ChatGPT or Claude by using the drop down at the top of the right hand nav bar.
 
 ## Further Reading
 
-* [Quickstart](/docs/gram/getting-started)
-* [Creating your first toolset](/docs/gram/build-mcp/create-default-toolset)
-* [Curating custom toolsets](/docs/gram/build-mcp/custom-toolsets)
-* [Deploying an MCP server](/docs/gram/host-mcp/deploy-mcp-server)
-* [OpenAPI concepts](/docs/gram/concepts/tool-sources)
-* [Tool definitions](/docs/gram/concepts/tool-definitions)
-* [Toolsets](/docs/gram/concepts/toolsets)
-* [Environment variables](/docs/gram/concepts/environments)
+- [Building tools in TypeScript using Gram Functions](/docs/gram/typescript)
+- [Getting started with Gram using an API spec](/docs/gram/openapi)
+- [Bring an existing MCP server to Gram](/docs/gram/gram-functions/mcp-sdk)
+- [Advanced tool curation](/docs/advanced/art-of-tool-curation)
+- [For resources on MCP see our MCP hub](/mcp)
+- [Adding OAuth to your MCP server](/docs/gram/host-mcp/adding-oauth)
+- [CLI reference](/docs/gram/command-line/installation)