---
title: "Build your graph in Savanna"
component: "savanna"
version: "main"
module: "get-started"
html_url: "/savanna/main/get-started/first-graph-ui.html"
---

[View as HTML](/savanna/main/get-started/first-graph-ui.html) · [Documentation index](/llms.txt)

# Build your graph in Savanna

This is the browser path to a working graph on TigerGraph Savanna: a running workspace, a schema you designed, data loaded against it, and a GSQL query returning results. Budget about fifteen minutes. The same graph is reachable afterward from an AI agent ([Connect AI tools with MCP](connect-agent-mcp.md)); the interface differs, the graph does not.

You'll need a [Savanna account](https://tgcloud.io) and some data to load. That can be a local CSV, TSV, or JSON file, or a source Savanna connects to directly, Amazon S3, Google Cloud Storage, Azure Blob Storage, Snowflake, and [more](../graph-development/load-data/index.md). Building the schema yourself is worth the extra time: you learn how Savanna models data, and you end up with a graph shaped for the questions you actually want to ask.

## Set up a workgroup and workspace

Savanna nests your work in two objects. A **workgroup** is a container for related workspaces and the boundary for access control; name it after a team or project. A **workspace** is the compute that runs your graph, and it's what you start, stop, and resize.

When you first register, Savanna creates a workgroup and a workspace for you. Wait until the workspace status is **active**, then continue below. You do not need to create either one to try the product.

To add another project later, **Create Workgroup** is a two-step wizard: the workgroup, then its first workspace. Choose **Read/Write** so the workspace can load data and install queries (a Read-Only workspace can query an existing graph but not load into it). You can resize later without rebuilding.

Full screens: [create a workgroup](../workgroup-workspace/workgroups/how2-create-a-workgroup.md) and [create a workspace](../workgroup-workspace/workspaces/how2-create-a-workspace.md).

## Model the graph

Open **Design Schema** from the navigation menu, the workspace page, or the GSQL Editor. The schema is the structure of your graph: which entities exist, how they connect, and what each one stores.

Start by creating a graph from the graph selector dropdown and giving it a name. Your first graph on a workspace can take up to two minutes while the services warm up.

Then lay out the model:

* **Vertices** are your entities, the nouns in your domain: a user, a product, a transaction, an account. Add one from the vertex button, or hold V and click on the canvas, then set its name and attributes in the properties panel.
* **Edges** are the relationships between them, the verbs: _placed_, _belongs to_, _transferred to_. Drag from the border of a vertex and drop onto another to connect two existing vertices, or drop onto empty canvas to create a new vertex and edge together. Name the edge and give it attributes if the relationship itself carries data, such as a timestamp or an amount.
* **Attributes** are the properties on either one, typed as strings, integers, booleans, or dates.

Give each vertex type a primary key that uniquely identifies an entity, since that's what the loader matches on when it creates and deduplicates vertices. Under **Advanced Settings** you can index non-primary attributes you expect to filter on, and add a reverse edge on a directed edge when you need to traverse it in both directions.

Modeling reference: [Schema Designer](../graph-development/design-schema/index.md).

## Load your data

Open **Load Data** and select an active workspace, then pick your connector. Savanna ships step-by-step flows for [local files](../graph-development/load-data/load-from-local.md), [Amazon S3](../graph-development/load-data/load-from-s3.md), [Google Cloud Storage](../graph-development/load-data/load-from-gcs.md), and [Azure Blob Storage](../graph-development/load-data/load-from-blob.md), with [Snowflake](../graph-development/load-data/load-from-snowflake.md) and [JDBC](../graph-development/load-data/jdbc.md) alongside them. Connectors without a guided flow yet hand you a GSQL template to finish in the editor instead.

The guided flow moves through three decisions:

**Configure the file.** Savanna detects delimiters and line breaks and shows you the parsed result. If the columns split wrong, change the delimiter, end-of-line, or quoting options. An enclosing character such as a double quote overrides the delimiter inside a token, which is what you want when string values contain commas. You can rename header columns here to something readable, since those names are what you'll map against.

**Map columns to the schema.** For each vertex and edge type, choose which source column feeds which attribute. **Quick Map** does the obvious matches in one pass: _map all to target_ aligns existing attributes with matching headers, while _map all from source_ also creates new attributes for headers that don't match anything yet. Where the source doesn't quite fit the target, a [token function](../graph-development/load-data/token-function.md) transforms the value as it loads.

**Confirm and run.** Savanna shows you _Schema to be changed_ and _Data to be loaded_ before anything executes. Read the schema diff carefully; some schema changes drop existing data, and the warning on that screen is the last checkpoint. Confirm to start the loading jobs, then watch their **Status** as they run.

Load vertices before the edges that reference them, so each edge finds both endpoints already present.

## Query it

Open the **GSQL Editor**. Queries are written in GSQL, TigerGraph's query language, and the editor gives you a file list on the left, the editing panel in the middle, results at the bottom, and the Schema Designer on the right when you need to check a type.

Create a query with the **+** next to your graph in the Query List. A useful first query starts from one vertex and walks one hop out: select a vertex by its primary key, traverse an edge type, and return the neighbors. That single traversal is the thing a graph database does that a relational join makes painful, so it's worth writing by hand once.

A custom query has to be **installed** before it can run. Select it in the Query List and click **Install**, then run it and read the result panel. Expect vertices, edges, paths, or computed values depending on what your query returns.

For a visual read on the same data, **Explore Graph** lets you walk vertices and their neighbors, and [pattern search](../graph-development/explore-graph/how2-use-pattern-search.md) finds paths between them without writing GSQL. It's the fastest way to confirm your edges connect what you think they connect.

Editing, installing, and sharing queries: [GSQL Editor guide](../graph-development/gsql-editor/how2-edit-gsql-query.md).

## You're done when

* The workspace is **active** and **Read/Write**.
* Your vertex and edge types appear in the Schema Designer for the graph you created.
* The loading jobs finished with a successful **Status** on the Load Data screen.
* An installed GSQL query returns graph data or computed values, or Explore Graph renders your vertices and edges.

If a loading job fails, the mapping is the usual cause: check that the parsed columns line up with the attributes you targeted and that primary keys aren't empty in the source. Fix the mapping and rerun the job; you don't need to recreate the workspace or the schema.

## Where to go next

* Point an AI agent at the same graph: [Connect AI tools with MCP](connect-agent-mcp.md).
* Model, load, and query in depth: [Build](../graph-development/index.md).
* In a hurry, or want a schema drafted for you? [Build a graph with AI](../build-ai/index.md) infers one from your files, and a [Marketplace solution](../integrations/solutions.md) ships with schema, data, and queries already in place.
* Unfamiliar term? [Glossary](../resources/glossary.md).
