graphprotocol · benface · Jul 14, 2025 · Jul 14, 2025 · Jul 14, 2025 · Jul 14, 2025
@@ -1,67 +1,46 @@
 ---
-title: حول The Graph
+title: About The Graph
+description: This page summarizes the core concepts and basics of The Graph Network.
 ---
 
 ## What is The Graph?
 
-The Graph is a powerful decentralized protocol that enables seamless querying and indexing of blockchain data. It simplifies the complex process of querying blockchain data, making dapp development faster and easier.
+The Graph is a decentralized protocol for indexing and querying blockchain data across [90+ networks](/supported-networks/).
 
-## Understanding the Basics
+Its data services include:
 
-Projects with complex smart contracts such as [Uniswap](https://uniswap.org/) and NFTs initiatives like [Bored Ape Yacht Club](https://boredapeyachtclub.com/) store data on the Ethereum blockchain, making it very difficult to read anything other than basic data directly from the blockchain.
+- [Subgraphs](/subgraphs/developing/subgraphs/): Open APIs to query blockchain data that can be created or queried by anyone.
+- [Substreams](/substreams/introduction/): High-performance data streams for real-time blockchain processing, built with modular components.
+- [Token API Beta](/token-api/quick-start/): Instant access to standardized token data requiring zero setup.
 
-### Challenges Without The Graph
+### Why Blockchain Data is Difficult to Query
 
-In the case of the example listed above, Bored Ape Yacht Club, you can perform basic read operations on [the contract](https://etherscan.io/address/0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d#code). You can read the owner of a certain Ape, read the content URI of an Ape based on their ID, or read the total supply.
+Reading data from blockchains requires processing smart contract events, parsing metadata from IPFS, and manually aggregating data.
 
-- This can be done because these read operations are programmed directly into the smart contract itself. However, more advanced, specific, and real-world queries and operations like aggregation, search, relationships, and non-trivial filtering, **are not possible**.
+The result is slow performance, complex infrastructure, and scalability issues.
 
-- For instance, if you want to inquire about Apes owned by a specific address and refine your search based on a particular characteristic, you would not be able to obtain that information by directly interacting with the contract itself.
+## How The Graph Solves This
 
-- To get more data, you would have to process every single [`transfer`](https://etherscan.io/address/0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d#code#L1746) event ever emitted, read the metadata from IPFS using the Token ID and IPFS hash, and then aggregate it.
+The Graph uses a combination of cutting-edge research, core dev expertise, and independent Indexers to make blockchain data accessible for developers.
 
-### Why is this a problem?
+Find the perfect data service for you:
 
-It would take **hours or even days** for a decentralized application (dapp) running in a browser to get an answer to these simple questions.
+### 1. Custom Real-Time Data Streams
 
-Alternatively, you have the option to set up your own server, process the transactions, store them in a database, and create an API endpoint to query the data. However, this option is [resource intensive](/resources/benefits/), needs maintenance, presents a single point of failure, and breaks important security properties required for decentralization.
+**Use Case:** High-frequency trading, live analytics.
 
-Blockchain properties, such as finality, chain reorganizations, and uncled blocks, add complexity to the process, making it time-consuming and conceptually challenging to retrieve accurate query results from blockchain data.
+- [Build Substreams](/substreams/introduction/)
+- [Browse Community Substreams](https://substreams.dev/)
 
-## The Graph Provides a Solution
+### 2. Instant Token Data
 
-The Graph solves this challenge with a decentralized protocol that indexes and enables the efficient and high-performance querying of blockchain data. These APIs (indexed "Subgraphs") can then be queried with a standard GraphQL API.
+**Use Case:** Wallet balances, liquidity pools, transfer events.
 
-Today, there is a decentralized protocol that is backed by the open source implementation of [Graph Node](https://github.com/graphprotocol/graph-node) that enables this process.
+- [Start with Token API](/token-api/quick-start/)
 
-### How The Graph Functions
+### 3. Flexible Historical Queries
 
-Indexing blockchain data is very difficult, but The Graph makes it easy. The Graph learns how to index Ethereum data by using Subgraphs. Subgraphs are custom APIs built on blockchain data that extract data from a blockchain, processes it, and stores it so that it can be seamlessly queried via GraphQL.
+**Use Case:** Dapp frontends, custom analytics.
 
-#### Specifics
-
-- The Graph uses Subgraph descriptions, which are known as the Subgraph manifest inside the Subgraph.
-
-- The Subgraph description outlines the smart contracts of interest for a Subgraph, the events within those contracts to focus on, and how to map event data to the data that The Graph will store in its database.
-
-- When creating a Subgraph, you need to write a Subgraph manifest.
-
-- After writing the `subgraph manifest`, you can use the Graph CLI to store the definition in IPFS and instruct an Indexer to start indexing data for that Subgraph.
-
-The diagram below provides more detailed information about the flow of data after a Subgraph manifest has been deployed with Ethereum transactions.
-
-![A graphic explaining how The Graph uses Graph Node to serve queries to data consumers](/img/graph-dataflow.png)
-
-تدفق البيانات يتبع الخطوات التالية:
-
-1.  A dapp adds data to Ethereum through a transaction on a smart contract.
-2.  العقد الذكي يصدر حدثا واحدا أو أكثر أثناء معالجة الإجراء.
-3.  Graph Node continually scans Ethereum for new blocks and the data for your Subgraph they may contain.
-4.  Graph Node finds Ethereum events for your Subgraph in these blocks and runs the mapping handlers you provided. The mapping is a WASM module that creates or updates the data entities that Graph Node stores in response to Ethereum events.
-5.  The dapp queries the Graph Node for data indexed from the blockchain, using the node's [GraphQL endpoint](https://graphql.org/learn/). The Graph Node in turn translates the GraphQL queries into queries for its underlying data store in order to fetch this data, making use of the store's indexing capabilities. The dapp displays this data in a rich UI for end-users, which they use to issue new transactions on Ethereum. The cycle repeats.
-
-## الخطوات التالية
-
-The following sections provide a more in-depth look at Subgraphs, their deployment and data querying.
-
-Before you write your own Subgraph, it's recommended to explore [Graph Explorer](https://thegraph.com/explorer) and review some of the already deployed Subgraphs. Each Subgraph's page includes a GraphQL playground, allowing you to query its data.
+- [Explore Subgraphs](https://thegraph.com/explorer)
+- [Build Your Subgraph](/subgraphs/quick-start)
@@ -0,0 +1,6 @@
+{
+  "graph-assistant": "Graph Assistant",
+  "ai-introduction": "The Graph's AI",
+  "subgraph-mcp": "Subgraph MCP",
+  "token-api-mcp": "Token API MCP"
+}
@@ -0,0 +1,58 @@
+---
+title: The Graph's AI
+---
+
+Build with speed and scale faster with The Graph's AI.
+
+## Using AI on The Graph
+
+Instead of relying on static datasets or centralized APIs, you can now access live blockchain data through our **agentic** app, [Graph Assistant](/ai-suite/graph-assistant/introduction/), and use our AI-native tooling, [Subgraph MCP](/ai-suite/subgraph-mcp/introduction/), and [Token API MCP](/ai-suite/token-api-mcp/introduction/).
+
+### Why Use Onchain Data with AI?
+
+Using onchain data with AI unlocks powerful new ways to interact with and understand blockchain ecosystems.
+
+- **AI for Non-Technical End Users**: AI can turn complex onchain data into accessible insights. Assistants powered by AI enable you to explore and analyze blockchain data without coding.
+- **AI for Developers**: You can use AI to interact directly with The Graph's data through your agents or build AI-powered applications on top of it. This streamlines development and opens up more intuitive, dynamic use cases.
+
+## AI for Non-Technical/End Users
+
+[Graph Assistant](/ai-suite/graph-assistant/introduction/) is a powerful **agentic** application that empowers users to easily interact with blockchain data. Ask questions in simple, natural language and get rich, AI powered insights. Both technical developers and non-technical product teams can move faster, make smarter decisions, and gain a clearer understanding than ever before.
+
+### Benefits of Using Graph Assistant
+
+- **Natural language Input**: You don't need to write complex queries or sift through dashboards. Simply ask your question in plain English and get clear, structured results.
+- **Multi-source support**: Works across multiple Subgraphs and Token API. The Assistant automatically determines which data source to use, so you don't have to switch tools or manage endpoints.
+- **Schema-free access**: You don't need to understand the schema. You can refer to tokens, protocols, dates, or addresses using natural language. The Assistant takes care of the rest.
+
+### Conversational Querying with Graph Assistant
+
+**Example queries:**
+
+- "List the top-5 swaps by USD value in the last 24 hours."
+- "Give me the daily volume on Uniswap."
+- "List the 20 most recently registered .eth names."
+
+[Graph Assistant](/ai-suite/graph-assistant/introduction/) will eventually be a one-stop shop for interacting with The Graph. Right now, it's an agentic AI app that uses state-of-the-art AI techniques, LLMs, and MCPs to understand and answer your questions about [Subgraphs](/subgraphs/developing/subgraphs/) and [Token API](/token-api/quick-start/) data.
+
+## AI for Developers
+
+### Enable Natural Language Access to Onchain Data
+
+[Model Context Protocol](https://modelcontextprotocol.io/introduction) (MCP) servers connect to Claude, Cline, and Cursor. They enable models to understand, query, and interact with structured onchain data using natural language. MCPs remove the need to write low-level queries or interact with APIs directly.
+
+### Subgraph MCP
+
+The [Subgraph MCP](/ai-suite/subgraph-mcp/introduction/) server connects models to Subgraphs on The Graph Network. It allows language models to explore Subgraph schemas, execute GraphQL queries, find relevant Subgraphs by keyword or contract, and surface usage metrics using natural language.
+
+### Token API MCP
+
+The [Token API MCP](/ai-suite/token-api-mcp/introduction/) MCP server enables models to access onchain token data. It supports querying token metadata, wallet balances, transfer history, and top token holders through simple prompts.
+
+#### Benefits of Using Subgraph and Token API MCPs
+
+- Query Subgraphs and token data using natural language
+- Access GraphQL schemas and token metadata without manual queries
+- Find Subgraphs by keyword or contract and check 30-day usage
+- Retrieve real-time data from The Graph and onchain token sources
+- Get wallet balances, transfer history, and top token holders
@@ -0,0 +1,26 @@
+---
+title: Graph Assistant FAQ
+sidebarTitle: FAQ
+---
+
+This page summarizes some of the most common questions for developers using Graph Assistant.
+
+1. What is The Graph Assistant?
+
+The Graph Assistant is an AI-powered chat interface that lets you query blockchain data in plain English. Under the hood, it translates your questions into GraphQL calls against Subgraphs and the Token API, then returns results, no coding required.
+
+2. What is an agentic application?
+
+An agentic application combines AI-driven reasoning with external data sources or APIs to take autonomous actions on your behalf. In this case, Graph Assistant acts as an “agent” that interprets your natural-language prompts, builds and dispatches GraphQL queries, and formats the results so that you don't need to write or manage queries yourself.
+
+3. Which networks and data does Graph Assistant support?
+
+The Assistant has access to Subgraphs across multiple chains. If a Subgraph is published to The Graph Network and is being indexed, the Assistant can automatically route queries to it. The Assistant also has access to the Token API on Ethereum Mainnet, BSC, Unichain, Arbitrum-One, Optimism, and Polygon.
+
+4. Is there a usage limit or quota?
+
+Yes, 10 questions per hour.
+
+5. What if the Assistant can't interpret my question?
+
+When the Assistant fails to parse your intent (for example, ambiguous token name, missing context, or an unsupported request), it will prompt you for clarification. For instance, it might ask, “Did you mean XYZ on Ethereum or XYZ on Arbitrum?” or “Please specify a date range for this query.” If you continue to see parsing errors, check that you're using correct token symbols or specifying networks and time frames clearly.
@@ -0,0 +1,56 @@
+---
+title: How To Use The Graph Assistant
+sidebarTitle: How-to Guide
+---
+
+## نظره عامة
+
+You type a natural language question into the chat interface, such as:
+
+```yaml
+'On Uniswap, return the top-10 pools by total value locked in USD.'
+```
+
+> [!IMPORTANT] All users can process 10 free queries per user per hour.
+>
+> [!NOTE] Disclaimer: By using Graph Assistant, you acknowledge that your requests may be logged and used to improve the performance of the underlying agents. Do not share sensitive, personal, or private information.
+
+### Behind the Scenes
+
+The Assistant:
+
+1. Interprets your intent
+2. Maps it to the correct Subgraphs or Token API endpoint
+3. Executes optimized queries
+4. Returns clean, structured results
+
+You don't need to write queries or understand a Subgraph's schema, you simply ask.
+
+### Example Use Cases
+
+**Protocol Analytics**
+
+- “Compare daily active users on Aave vs. Compound in May 2025.”
+- “Show me the total value locked (TVL) for XYZDAO over the last quarter.”
+
+**Token Insights**
+
+- “What are the top 10 tokens by market cap on Ethereum right now?”
+- “How many XYZ did I receive between May 1 and May 15?”
+
+**Historical Data Retrieval**
+
+- “Fetch the token price history of XYZ for the last six months.”
+- “What was the average gas price on Ethereum during April?”
+
+**Portfolio Monitoring**
+
+- “List my wallet’s current token balances and their USD equivalents.”
+- “Calculate profit/loss on XYZ since xyz date.”
+
+**Cross-Chain Comparison**
+
+- “Show me the 7-day trading volume of XYZ on Ethereum vs. Polygon.”
+- “How many XYZ swaps occurred on Arbitrum yesterday?”
+
+To get started follow the [quickstart](/ai-suite/graph-assistant/quick-start/) and explore its capabilities.
@@ -0,0 +1,31 @@
+---
+title: مقدمة
+---
+
+> [!IMPORTANT] Graph Assistant is still in **beta**. Expect breaking changes, rate limits, and potential downtime.
+
+[Graph Assistant](https://thegraph.com/graph-assistant) (Beta) gives instant, code-free access to blockchain data, transforming natural language into precise, AI-powered queries without the need to code.
+
+## نظره عامة
+
+[Graph Assistant](https://thegraph.com/graph-assistant) is an advanced, [agentic](/en/ai-suite/graph-assistant/faq/) easy-to-use chat interface for querying blockchain data using natural language. Unlike a basic chatbot, Graph Assistant can understand your intent, build complex queries, and execute them automatically. This gives you rich, AI-powered insights from onchain data without writing any code.
+
+- **Automatically** interprets user intent, generates precise queries, executes them via The Graph's Subgraphs and Token API, and presents structured, AI-powered answers without requiring any code.
+- **Removes** the technical complexity found in traditional dashboards or chatbots. It provides composable insights directly from indexed Subgraphs and Token datasets.
+
+## Core Features
+
+| Feature                      | الوصف                                                                                                                                                                                                  |
+| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **Friendly Interface**       | Conversational access to blockchain data via natural language. You simply ask questions, the Assistant fetches the answer, and renders results.                                                        |
+| **Backed by Subgraphs**      | Uses subgraphs to index protocol-specific data like transactions, events, and protocol metrics.                                                                                                        |
+| **Backed by Token API**      | Uses Token API for token-level information like balances, transfers, and metadata.                                                                                                                     |
+| **No Setup Required**        | No need to configure data sources or write queries.                                                                                                                                                    |
+| **Automatic Query Building** | The Assistant performs complex queries such as fetching historical token volumes, protocol analytics, or cross-chain data and handles filtering, pagination, and joins across Subgraphs automatically. |
+
+## Help Shape What's Next
+
+This is in **beta**, and community input is essential. If you have ideas, questions, or run into anything unexpected, we'd love to hear from you:
+
+- Join the community on [Discord](https://discord.com/invite/graphprotocol): Provide feedback and stay in the loop with other builders. You'll be able to join the `#graph-assistant` channel to share your experience directly.
+- Interested in going deeper? Reach out to become a dedicated beta tester so your specific use case can be better supported.
@@ -0,0 +1,44 @@
+---
+title: بداية سريعة
+---
+
+> [!IMPORTANT] Graph Assistant is still in **beta**. Expect breaking changes, rate limits, and potential downtime.
+
+This guide provides step-by-step instructions for getting started with Graph Assistant quickly.
+
+## Step-by Step
+
+### Step 1. Create an Account
+
+Go to: [Graph Assistant](https://thegraph.com/graph-assistant)
+
+- Click Sign Up (or Log In if you already have an account).
+- Use your Google, GitHub, X, email or wallet credentials to log in.
+- No additional setup is required.
+
+### Step 2. Open the Assistant Chat
+
+After logging in:
+
+- You'll see Graph Assistant's interface.
+- At the bottom of the page, you will find a chat input bar. This is where you will interact with the Assistant.
+
+### Step 3: Ask Your First Question
+
+> [!IMPORTANT] All users can process 10 free queries per user per hour.
+
+In the input bar, type a natural-language query (everyday language).
+
+Example:
+
+```yaml
+Show me the 24-hour trading volume of XYZ token on Ethereum
+```
+
+> [!NOTE] Disclaimer: By using Graph Assistant, you acknowledge that your requests may be logged and used to improve the performance of the AI interface. Do not share sensitive, personal, or private information.
+
+The Assistant will:
+
+- Digest your question
+- Fetch onchain data using Subgraphs or the Token API
+- Return a clean, formatted response with the data you need