> ## Documentation Index
> Fetch the complete documentation index at: https://docs.graphify.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> The PyPI package is graphifyy, with two y's. The command is graphify.
> /graphify . is typed in an assistant chat, not in a shell.
> Use only commands, flags, and endpoints shown on these pages. Do not invent one.
> Choose the surface before you open a page. [Local] is the graphifyy package on the machine: the skill, the CLI, and the ten-tool MCP. [Cloud] is the hosted workspace and https://api.graphify.com/mcp (Streamable HTTP, OAuth, no API key). [Both] applies to either surface. Buildkite is the CI integration.
> Each page line in llms.txt starts with [Local], [Cloud], or [Both].
> The docs changelog summarizes selected graphifyy releases. The current package version is on PyPI (https://pypi.org/project/graphifyy/). The full history is https://graphify.com/changelog.
> The official site is https://graphify.com. These docs are https://docs.graphify.com.
> The local MCP server is the ten tools in the MCP tool reference and reads a graph on the machine. The hosted server is https://api.graphify.com/mcp (Streamable HTTP, OAuth, no API key). The VS Code, JetBrains, OpenClaw, Vercel, and Other coding agents pages, and the page ChatGPT, Codex, and Dots, use the hosted server, not the ten-tool list. Other coding assistants is the local skill for clients without their own page. The page titled Graphify with Codex is the local skill.
> Read https://docs.graphify.com/llms.txt, then open one page's .md link. Use https://docs.graphify.com/llms-full.txt only when one page is not enough.

# Move from local to Cloud

> [Both] Move one repository from the local graphifyy package to Graphify Cloud. Switch each assistant to the hosted MCP server, and keep the local graph so you can roll back.

Move a repository from the local `graphifyy` package to Graphify Cloud. Cloud indexes the repository on GitHub or GitLab. Your assistants then query that graph through the hosted server at `https://api.graphify.com/mcp`.

This is a configuration change. Your application code stays as it is. Each assistant keeps reading the local graph until you switch its `graphify` entry. Leave `graphify-out/` in place until you are sure the hosted server answers, so you can roll back.

## Overview

| Scope | Effort | Downtime |
| - | - | - |
| Assistant configuration, tool calls, and saved lessons | Configuration only. Your application code stays as it is. | None. Each assistant reads the local graph until you switch it. |

> [!NOTE]
>
> Cloud indexes repositories on GitHub or GitLab. A project that exists only on your machine stays on the local package.

> [!NOTE]
>
> **Why move to Cloud?**
>
> * **The graph updates itself.** Cloud indexes on each push to the default branch. You stop running `graphify update .` and the git hooks that rebuild the local graph.
> * **One connection for the workspace.** Assistants sign in once and name any indexed repository, such as `your-org/your-repo`. Local paths leave the MCP config.
> * **Reviews on every pull request.** Graphify comments when a pull request is opened, reopened, or marked ready for review.
> * **Learning from your team's replies.** Feedback on findings tunes what later reviews surface.
> * **Formal verification on changed functions.** Each result says whether behavior is preserved, or which input produces a different result.
> * **A wiki you can search and ask.** Generated from the indexed graph, with links back to the code in **Graphs**.
> * **Shared memory for the team.** Notes for a repository are available to every assistant and teammate in the workspace.
> * **OAuth sign-in.** Each assistant signs in through the browser. There is no API key to paste into a config file.

### Plan

1. **Sign in.** Open [app.graphify.com](https://app.graphify.com) and sign in with Google, GitHub, GitLab, or email. If you are new to Graphify, choose **Create an account** on the login page.
2. **Check the repository.** It is on GitHub or GitLab, and the commits you want in the graph are on its default branch. You need permission on the provider to grant Graphify access to it.
3. **Choose how assistants sign in.** Each assistant signs in with OAuth the first time it connects. An agent that cannot open a browser, such as one in CI, uses an API token instead.
4. **Find every local use.** From the repository root, run the list command for each assistant you use:

```bash theme={null}
claude mcp list
codex mcp list
graphify hook status
git grep --untracked -n -e graphify-mcp -e graphify-out -e "graphify query" -e "graphify extract"
```

Look for MCP entries named `graphify` that run `graphify-mcp`, skill registrations from `graphify install`, git hooks, CI jobs that run `graphify extract`, and scripts that read `graphify-out/`. Also search your assistant rules for local tool names such as `get_node` and `god_nodes`. In Cursor and VS Code, open the MCP files named under each assistant in [Switch each assistant to the hosted server](#2-switch-each-assistant-to-the-hosted-server).

## Move with your assistant

Paste this prompt into the assistant you are moving. It reads this page, lists every local Graphify piece it finds, and shows the change it proposes for each. After you approve that list, it makes the edits and stops so you can sign in yourself.

```text theme={null}
Help me move this repository from the local Graphify package (graphifyy) to Graphify Cloud.

Read https://docs.graphify.com/platform/local-to-cloud.md first and follow it for this assistant.

Start with a plan. List every MCP server entry named graphify that runs graphify-mcp, in each scope and configuration file this assistant reads. Also list Graphify skill files, git hooks, and any rule, prompt, or script that names a local Graphify tool. For each item, show the change you propose. Wait for my approval before you edit anything.

When I approve, replace each local graphify entry with the hosted Streamable HTTP server at https://api.graphify.com/mcp under the same name. Keep every other MCP server and setting as it is. Let me complete the OAuth sign-in myself.

Leave graphify-out/ and the local Graphify skill in place. I will remove them after the hosted server answers.

To verify, use Graphify's list_repositories tool and show the repositories I can access. If the tool fails, report the error instead of guessing. Do not claim the move succeeded until a hosted tool has answered.
```

## Move by hand

### 1. Connect the repository

1. Open **Repositories** in [Graphify Cloud](https://app.graphify.com).
2. Choose **Connect GitHub** or **Connect GitLab**.
3. Complete the provider's repository-access flow.
4. Wait until the repository's status is **Indexed**.

| Status | What to do |
| - | - |
| **Indexed** | Go to step 2. |
| **Queued** or **Building** | Wait. The local graph keeps answering in the meantime. |
| **Failed** | Open **Builds** and choose **Retry**. Retry indexes the current head of the default branch. |
| **Paused** | Open **Options** for the repository and switch **Indexing** on. |

> [!NOTE]
>
> The local graph describes your folder as it was at the last build or update, uncommitted changes included. Cloud's graph describes the latest indexed commit on the default branch. A push to another branch, or a pull request, does not change it. See [Repositories and builds](https://docs.graphify.com/platform/repositories.md).

### 2. Switch each assistant to the hosted server

Switch one assistant at a time. Each tab shows the local entry you have now and the hosted entry that replaces it. Keep the name `graphify`. Leave every other MCP server as it is.

Keep the `graphifyy` package until the move is done. The rollback steps use it.

**Claude Code**

Claude Code checks the local scope, then the project scope, then the user scope, and uses the first `graphify` entry it finds. A local-scope entry for the local server hides the hosted one. Remove it first.

```bash Local (before) theme={null}
claude mcp add --transport stdio graphify -- graphify-mcp /absolute/path/to/repo/graphify-out/graph.json
```

```bash Cloud (after) theme={null}
claude mcp remove graphify --scope local
claude mcp add --transport http --scope user graphify https://api.graphify.com/mcp
```

Run the commands from the repository folder where you added the local server. If you added it with `--scope user`, run `claude mcp remove graphify --scope user` instead of the first command.

In Claude Code, run `/mcp`. Select **graphify** and choose **Authenticate**. Finish the sign-in in the browser window that opens. `claude mcp list` then shows `graphify` with the URL `https://api.graphify.com/mcp`.

If the repository commits a `.mcp.json` that runs `graphify-mcp`, replace its `graphify` entry:

```json .mcp.json (before) theme={null}
{
  "mcpServers": {
    "graphify": {
      "command": "graphify-mcp",
      "args": ["/absolute/path/to/repo/graphify-out/graph.json"]
    }
  }
}
```

```json .mcp.json (after) theme={null}
{
  "mcpServers": {
    "graphify": {
      "type": "http",
      "url": "https://api.graphify.com/mcp"
    }
  }
}
```

Each teammate approves the shared entry once, then signs in from `/mcp`.

**Cursor**

The entry is in `.cursor/mcp.json` in the repository, or in `~/.cursor/mcp.json` for your user.

```json Local (before) theme={null}
{
  "mcpServers": {
    "graphify": {
      "command": "graphify-mcp",
      "args": ["/absolute/path/to/repo/graphify-out/graph.json"]
    }
  }
}
```

```json Cloud (after) theme={null}
{
  "mcpServers": {
    "graphify": {
      "url": "https://api.graphify.com/mcp"
    }
  }
}
```

Keep the other servers in the file. Cursor shows **Needs login** until you finish the one-time sign-in in your browser.

**Codex**

`codex mcp add` and `codex mcp remove` edit `~/.codex/config.toml`. A project can also define `graphify` in `.codex/config.toml`.

```toml Local (before) theme={null}
[mcp_servers.graphify]
command = "graphify-mcp"
args = ["/absolute/path/to/repo/graphify-out/graph.json"]
```

```toml Cloud (after) theme={null}
[mcp_servers.graphify]
url = "https://api.graphify.com/mcp"
auth = "oauth"
```

To make the same change from the terminal:

```bash theme={null}
codex mcp remove graphify
codex mcp add graphify --url https://api.graphify.com/mcp
codex mcp login graphify
```

Complete the browser sign-in that `codex mcp login graphify` opens. A hand edit to the TOML needs that login command too. Then open a new Codex session and use `/mcp` to check that **graphify** is available.

**VS Code**

The entry is in `.vscode/mcp.json`, or in the file that **MCP: Open User Configuration** opens.

```json Local (before) theme={null}
{
  "servers": {
    "graphify": {
      "type": "stdio",
      "command": "graphify-mcp",
      "args": ["/absolute/path/to/repo/graphify-out/graph.json"]
    }
  }
}
```

```json Cloud (after) theme={null}
{
  "servers": {
    "graphify": {
      "type": "http",
      "url": "https://api.graphify.com/mcp"
    }
  }
}
```

To skip the hand edit, remove the local entry and install the [Graphify MCP extension](https://docs.graphify.com/integrations/vscode.md). Use one path or the other. With both, the same tools appear twice.

To sign in, run **MCP: List Servers** from the Command Palette. Select **Graphify** and start it. Your browser opens for the sign-in.

**Copilot CLI**

If you added the local server to `~/.copilot/mcp-config.json`, remove its `graphify` entry. Then add the hosted server:

```bash Terminal theme={null}
copilot mcp add --transport http graphify https://api.graphify.com/mcp
```

```json ~/.copilot/mcp-config.json theme={null}
{
  "mcpServers": {
    "graphify": {
      "type": "http",
      "url": "https://api.graphify.com/mcp",
      "tools": ["*"]
    }
  }
}
```

`tools` is Copilot's own list of allowed tools. Without it, the server connects and its tools stay unavailable. Copilot CLI signs in on first connect. `/mcp show` lists what is connected.

**Other clients**

```json Local (before) theme={null}
{
  "mcpServers": {
    "graphify": {
      "command": "graphify-mcp",
      "args": ["/absolute/path/to/repo/graphify-out/graph.json"]
    }
  }
}
```

```json Cloud (after) theme={null}
{
  "mcpServers": {
    "graphify": {
      "url": "https://api.graphify.com/mcp"
    }
  }
}
```

Field names vary by client. Windsurf names the URL field `serverUrl`. The file or command for each client is on the [Graphify MCP connection guide](https://graphify.com/mcp). JetBrains, ChatGPT, OpenClaw, and Vercel have their own pages in [Choose your coding assistant](https://docs.graphify.com/integrations/overview.md).

An assistant that cannot open a browser, such as one in CI, uses an API token. On the **MCP** tab of **Connectors**, choose **Use an API token for CI or headless agents**.

### 3. Check that the hosted server answers

Start a new session in the assistant and paste the connection test prompt from the console:

```text theme={null}
Use Graphify's list_repositories tool and show the repositories I can access. If the tool fails, report the error instead of guessing.
```

The answer lists each repository's full name, such as `your-org/your-repo`, and whether its index is ready. The hosted server is connected when the assistant's tools include `list_workspaces` and `list_repositories`. If the tools include `get_node` or `god_nodes`, the assistant still reads the local graph. Return to step 2 for that assistant.

Then compare one answer. Ask a question with the local CLI:

```bash theme={null}
graphify query "authentication flow"
```

Ask the assistant the same question about `your-org/your-repo`. Cloud indexes the default branch, so answers can differ where your working copy has changes the default branch lacks. Open the cited source lines before you trust an answer.

To set the repository an assistant uses when a tool call names none, choose a **Default repository** on the **MCP** tab of **Connectors**.

### 4. Update tool calls

> [!WARNING]
>
> **Hosted calls name the repository.** One hosted connection serves every indexed repository in your workspace. Pass `repository_id` on each repository tool, as `owner/name` or the UUID that `list_repositories` returns. You can leave it out when the workspace has one repository.

> [!NOTE]
>
> Several inputs have new names. `label` is `symbol`. On `query_graph`, `token_budget` is `budget`. `shortest_path` takes `src` and `tgt` in place of `source` and `target`. The local `project_path` input becomes `repository_id`.

If a rule, prompt, or script calls a local tool, change it to the hosted tool for the same job.

| Job | Local call | Hosted call |
| - | - | - |
| Ask a question | `query_graph` with `question` | `query_graph` with `repository_id` and `question` |
| Read one symbol | `get_node` with `label` | `graphify_node` with `repository_id` and `symbol` |
| List direct neighbors | `get_neighbors` with `label` | `graphify_node` for every neighbor. `graphify_callers`, `graphify_callees`, or `graphify_references` for one kind of edge. |
| Connect two symbols | `shortest_path` with `source` and `target` | `shortest_path` with `src` and `tgt`. `graphify_trace` for directed call paths. |
| Summarize the graph | `graph_stats` with no input | `graph_stats` with `repository_id` |
| Find the most connected code | `god_nodes` | Open **Graphs** in the console. It lists the most connected areas. |
| Read one community | `get_community` with `community_id` | Open **Graphs** in the console. **All code areas** picks an area. |
| Check pull requests | `list_prs`, `get_pr_impact`, or `triage_prs` | Open **Reviews** in the console. `graphify_impact` and `impact_and_risk` show what a change reaches. |

`query_graph`, `shortest_path`, and `graph_stats` keep their names. Replace `your-org/your-repo` in these examples with a full name from `list_repositories`.

> **Ask a question**
>
> ```json query_graph (local) theme={null}
> {"question": "request validation", "mode": "bfs", "token_budget": 1500}
> ```
>
> ```json query_graph (Cloud) theme={null}
> {"repository_id": "your-org/your-repo", "question": "Where is request validation handled?", "budget": 1500}
> ```
>
> The hosted tool has no `mode`, `depth`, or `context_filter` input. Full sentences work better than keywords. Set `skeleton` to `true` to get signatures and outlines in place of full definition bodies.

> **Read one symbol**
>
> ```json get_node (local) theme={null}
> {"label": "normalize_email"}
> ```
>
> ```json graphify_node (Cloud) theme={null}
> {"repository_id": "your-org/your-repo", "symbol": "normalize_email"}
> ```
>
> `graphify_node` returns the definition and its immediate neighbors. If the name does not match, it can return a similar symbol. Check the `resolved` field: `exact` is the symbol you asked for, and `semantic` is a suggested match.

> **List the callers of a symbol**
>
> ```json get_neighbors (local) theme={null}
> {"label": "normalize_email", "relation_filter": "calls"}
> ```
>
> ```json graphify_callers (Cloud) theme={null}
> {"repository_id": "your-org/your-repo", "symbol": "normalize_email"}
> ```
>
> Use `graphify_callees` for what the symbol calls, and `graphify_references` for reads and mentions that are not calls. `strict_calls` is `true` by default, which keeps only resolved call edges. Set it to `false` to include inferred edges.

> **Connect two symbols**
>
> ```json shortest_path (local) theme={null}
> {"source": "login", "target": "normalize_email", "max_hops": 8}
> ```
>
> ```json shortest_path (Cloud) theme={null}
> {"repository_id": "your-org/your-repo", "src": "login", "tgt": "normalize_email"}
> ```
>
> ```json graphify_trace (Cloud) theme={null}
> {"repository_id": "your-org/your-repo", "src": "login", "tgt": "normalize_email", "k_paths": 3}
> ```
>
> The hosted tools have no `max_hops` or `undirected` input. `graphify_trace` returns directed call paths, and `k_paths` sets how many.

> **Summarize the graph**
>
> ```json graph_stats (local) theme={null}
> {}
> ```
>
> ```json graph_stats (Cloud) theme={null}
> {"repository_id": "your-org/your-repo"}
> ```
>
> The hosted result has node and edge counts and languages. It is also a quick check that the repository is indexed.

The hosted server also has tools that the local server lacks:

* `graphify_find` locates where a symbol is defined, from a fragment of its name.
* `graphify_tests_for` finds tests linked to a symbol or file.
* `graphify_file_neighbors` and `graphify_imports_exports` show what a file imports and what imports it.
* `graphify_rank_files` ranks source files by relevance to a question.
* `impact_and_risk` ranks the files a change reaches, using their linked tests.
* `list_workspaces` and `set_workspace` list and switch workspaces.
* `remember`, `recall`, and `memories_about` save and read workspace notes.

Some tools save notes or change the selected workspace. Approve a tool only when that is what you meant. [ChatGPT, Codex, and Dots](https://docs.graphify.com/integrations/chatgpt.md) describes each hosted tool.

### 5. Move saved lessons into Memory

If you used `graphify save-result` and `graphify reflect`, your lessons live in `graphify-out/reflections/LESSONS.md` on your machine. Cloud keeps its own notes for each repository in **Memory**. There is no import for that file. Copy the lessons you still trust by hand:

1. Check each lesson against the current source. Leave out any lesson the code no longer supports.
2. Open **Memory** in the console and choose the repository.
3. Choose **Add memory** and save the lesson as a note.

An assistant on the hosted server can save the same note with `remember`:

```bash graphify save-result (local) theme={null}
graphify save-result --question "Where is email normalized?" \
  --answer "normalize_email handles normalization before lookup." \
  --nodes normalize_email --outcome useful
```

```json remember (Cloud) theme={null}
{"repository_id": "your-org/your-repo", "text": "normalize_email handles normalization before lookup.", "tags": ["auth"]}
```

`remember` has no outcome field. Put the outcome in the text or in `tags`. Notes from `remember` can wait under **Needs review** in **Memory** until an authorized member accepts them.

To read notes back, use `memories_about` with a file or symbol, or `recall` with a question:

```json memories_about (Cloud) theme={null}
{"repository_id": "your-org/your-repo", "target": "normalize_email"}
```

```json recall (Cloud) theme={null}
{"repository_id": "your-org/your-repo", "query": "How is email normalized?"}
```

Notes in **Memory** are shared with the workspace. Move only lessons that everyone in the workspace may read.

### 6. Retire graph builds in CI

If a CI job runs `graphify extract` to build a graph for assistants, remove the job once every assistant uses the hosted server. Cloud builds the graph on each push to the default branch. Keep the job if something other than an assistant reads its output.

If your workspace uses Buildkite with Graphify, Cloud can also select the tests a pull request affects. See [Buildkite test selection](https://docs.graphify.com/integrations/buildkite.md).

### 7. Remove the local setup

The local skill installs instructions that tell each assistant to query the local graph. Some assistants also get hooks that do the same. Remove them once every assistant answers from the hosted server.

For a personal install, run this from the repository root:

```bash theme={null}
graphify uninstall
```

That command removes your registrations for every assistant and the repository's Graphify git hooks. It also edits instruction files in the repository, such as `CLAUDE.md` and `AGENTS.md`, and deletes `.cursor/rules/graphify.mdc`. Review those changes with `git status` before you commit. The command keeps `graphify-out/` unless you add `--purge`.

For a registration the repository commits, run this once for each assistant, then commit the change:

```bash theme={null}
graphify uninstall --project --platform cursor
```

Teammates who installed the skill or the git hooks themselves run `graphify uninstall` in their own clone.

When you no longer need a way back, run `graphify uninstall --purge` to delete `graphify-out/`. If the repository commits `graphify-out/`, commit the deletion. Then remove the package:

```bash theme={null}
uv tool uninstall graphifyy
```

If you installed with pipx, run `pipx uninstall graphifyy`.

## What Cloud adds

These features run on the repositories you connect. Open each one after the hosted server answers.

> **Pull request reviews**
>
> > [!NOTE]
> >
> > **Why it matters:** Each pull request is reviewed against the indexed graph and the pull request's diff. You see the code a change can affect before it merges.
>
> Graphify reviews a pull request when it is opened, reopened, or marked ready for review. To review the current head after new commits, a repository owner, member, or collaborator comments on the pull request:
>
> ```text theme={null}
> @graphify review
> ```
>
> Read the results in **Reviews**. See [Pull request reviews](https://docs.graphify.com/platform/reviews.md).

> **Learning from review feedback**
>
> > [!NOTE]
> >
> > **Why it matters:** Your team's feedback on findings tunes what later advisory reviews surface and what stays quiet.
>
> Reply in the pull request conversation with the exact finding name from the Graphify review:
>
> ```text theme={null}
> @graphify wrong <finding>
> @graphify good <finding>
> @graphify suppress <rule>
> ```
>
> Learning leaves formal verification unchanged. See [Learning](https://docs.graphify.com/platform/learning.md).

> **Formal verification**
>
> > [!NOTE]
> >
> > **Why it matters:** A changed function is compared with its earlier implementation. The result says whether behavior is preserved, or which input produces a different result.
>
> Open **Formal Verification**, choose the repository, and expand a run. A function's result is **Proved equivalent (bounded)**, **Behavior change**, **No divergence sampled (not proven)**, **Abstained**, or **Errored**. See [Formal verification](https://docs.graphify.com/platform/verification.md).

> **Wiki**
>
> > [!NOTE]
> >
> > **Why it matters:** `graphify export wiki` writes Markdown files on your machine. The hosted wiki is generated for each indexed repository. You can search it or ask it questions in the console.
>
> Open **Wiki** and select a repository. Start with **Overview**. **Search** finds words in articles. **Ask** answers questions that need connected code context, such as a call path or where a behavior lives. Links open the matching code in **Graphs**. See [Wiki](https://docs.graphify.com/platform/wiki.md).

> **Shared memory**
>
> > [!NOTE]
> >
> > **Why it matters:** A note saved for a repository is available to every assistant and teammate in the workspace, with its source and history.
>
> Ask what the workspace remembers about a file or symbol before you change it:
>
> ```json memories_about theme={null}
> {"repository_id": "your-org/your-repo", "target": "app/models/message.rb"}
> ```
>
> See [Agent memory](https://docs.graphify.com/platform/memory.md).

> **Tests linked to a symbol**
>
> > [!NOTE]
> >
> > **Why it matters:** Before you change a symbol, you can list the tests linked to it. `impact_and_risk` combines the code a symbol reaches with its linked tests into a ranked list of files.
>
> ```json graphify_tests_for theme={null}
> {"repository_id": "your-org/your-repo", "target": "normalize_email"}
> ```
>
> ```json impact_and_risk theme={null}
> {"repository_id": "your-org/your-repo", "target": "normalize_email"}
> ```
>
> Both results come from the indexed graph. They do not run tests or replace a review.

## Summary of changes

| Area | Local package | Graphify Cloud | Action required |
| - | - | - | - |
| **Graph build** | `/graphify .` or `graphify extract` on your machine | Indexed from the default branch on GitHub or GitLab | Connect the repository |
| **Updates** | `graphify update .`, `graphify watch .`, or git hooks | Each push to the default branch | Remove the hooks after the move |
| **Connection** | `graphify-mcp` over stdio, with a path to `graph.json` | `https://api.graphify.com/mcp` over Streamable HTTP | Replace the `graphify` entry |
| **Sign-in** | None | OAuth in the browser, or an API token for CI | Sign in once in each assistant |
| **Repository** | One `graph.json` for each entry, or `project_path` | `repository_id` on each call | Add `repository_id` to tool calls |
| **Tool names** | `get_node`, `get_neighbors`, and `shortest_path` with `source` and `target` | `graphify_node`, `graphify_callers`, and `shortest_path` with `src` and `tgt` | Update rules and scripts |
| **Pull requests** | `list_prs`, `get_pr_impact`, and `triage_prs` through `gh` | **Reviews** | Read reviews in **Reviews** |
| **Saved lessons** | `graphify-out/reflections/LESSONS.md` | **Memory** for each repository | Copy lessons by hand |
| **Change impact** | `graphify affected "<node>"` | `graphify_impact` and `impact_and_risk` | Update scripts and prompts |
| **Wiki** | `graphify export wiki` | **Wiki** for each indexed repository | None |
| **Several repositories** | `graphify merge-graphs` or `graphify global add` | **Cross-Repository** in **Graphs** | Connect each repository |
| **Team** | Each clone installs the skill and the hooks | **Members** in the user menu | Invite teammates from **Members** |

## If something fails

| What you see | What to do |
| - | - |
| The tools include `get_node` or `god_nodes` | The assistant still reads the local graph. Remove the local `graphify` entry in step 2. In Claude Code, `claude mcp list` shows every entry. |
| The same tools appear twice | Two entries reach the hosted server, such as the VS Code extension and a manual entry. Keep one. |
| The assistant asks for an API key | The hosted server uses OAuth. Finish the sign-in in the browser. For CI, use an API token from the **MCP** tab of **Connectors**. |
| A tool call fails and names repositories | The call needs `repository_id`. Pass one of the names in the error, or run `list_repositories`. |
| `graphify_node` returns a different symbol | The name did not match, so the tool returned a similar one. Check `resolved`, then search with `graphify_find` and a fragment of the name. |
| The repository is missing | It is not indexed yet, or it is in another workspace. Check its status on **Repositories**, and check the workspace with `list_workspaces`. |
| An answer misses code you can see locally | Cloud indexes the default branch. Push that code to the default branch and wait for **Indexed**. |

## Roll back

The local graph stays in `graphify-out/` until you delete it, so you can go back at any point.

1. **Restore the entry.** In each assistant, replace the hosted `graphify` entry with the **Local (before)** entry from step 2. [Connect the graph MCP server](https://docs.graphify.com/mcp/overview.md) has the command for each client.
2. **Reinstall what you removed.** If you removed the package, run `uv tool install "graphifyy[mcp]"`. If you removed the skill, register it again, for example with `graphify install --platform cursor`. Add `--project` for a registration the repository commits.
3. **Refresh the graph.** Run `graphify update .`. If you used git hooks, run `graphify hook install`.
4. **Verify.** Ask the assistant to call `graph_stats`, then `query_graph` with a question about the repository.

To stop Cloud from indexing the repository, open **Options** for it on **Repositories** and switch **Indexing** off. Its status changes to **Paused**.

## Next steps

* [Graphify Cloud](https://app.graphify.com): open the repository you just connected, then try **Reviews**, **Wiki**, or **Memory**.
* [Pull request reviews](https://docs.graphify.com/platform/reviews.md): when a review runs and how to read its findings.
* [Agents and integrations](https://docs.graphify.com/platform/connections.md): connect more assistants to the hosted server.

> **[Console tour](https://docs.graphify.com/platform/console.md)**
>
> Every screen in the Cloud workspace, and what each one is for.

> **[When something fails](https://docs.graphify.com/platform/when-stuck.md)**
>
> Fix an empty graph, a failed build, or a stuck index.

[Suggest edits](https://github.com/Graphify-Labs/docs/edit/main/platform/local-to-cloud.mdx)
[Raise issue](https://github.com/Graphify-Labs/docs/issues/new?title=Issue%20on%20docs\&body=Path%3A%20%2Fplatform%2Flocal-to-cloud)

[PreviousConsole tour](https://docs.graphify.com/platform/console.md)
[NextTrace who calls this](https://docs.graphify.com/platform/trace.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.