# Graphify MCP Server: Functionality and Exposed Tools Explained

> Discover how Graphify MCP server functions and its exposed REST API endpoints for managing knowledge graph data. Explore its pluggable backends for SQLite or PostgreSQL.

- Repository: [Graphify Labs/graphify](https://github.com/Graphify-Labs/graphify)
- Tags: deep-dive
- Published: 2026-07-15

---

**The Graphify MCP (Model Compute Process) server is a lightweight HTTP service that exposes four core REST endpoints—`/api/ingest`, `/api/query`, `/api/export`, and `/health`—to manage knowledge graph data with pluggable SQLite or PostgreSQL backends.**

The Graphify MCP server acts as the central ingestion and query gateway for the Graphify knowledge graph platform. Designed for containerized deployment, it provides a stateless REST API that handles document ingestion, graph queries, and data exports while supporting multiple storage backends via environment variables. Understanding how this server functions and which tools it exposes is essential for developers integrating Graphify into their data pipelines.

## What Is the Graphify MCP Server?

The Graphify MCP server is a Docker-friendly HTTP service that manages the entire lifecycle of knowledge graph data. According to the source documentation in [`docs/docker-mcp-sqlite.md`](https://github.com/Graphify-Labs/graphify/blob/main/docs/docker-mcp-sqlite.md), the server runs as a standalone process that listens on port `8000` by default and delegates persistence to either SQLite or PostgreSQL based on runtime configuration.

The architecture follows a thin-handler pattern: HTTP requests are received by the server layer, validated, and forwarded to Graphify's core graph-processing engine. This engine handles document indexing, symbol resolution, and query execution independently of the transport protocol, keeping the HTTP API focused strictly on data marshalling and request routing.

## Core Architecture and Configuration

### Pluggable Storage Backend

At startup, the server inspects the `STORAGE_BACKEND` environment variable to initialize the appropriate persistence layer. As documented in [`docs/mcp-api.md`](https://github.com/Graphify-Labs/graphify/blob/main/docs/mcp-api.md), the supported values are:

- **`sqlite`** (default): Uses a local file specified by `SQLITE_DB_PATH` (defaults to `/data/graphify.db`)
- **`postgres`**: Connects to a remote database using the connection string provided in `POSTGRES_CONNECTION_URL`

This design allows the same Docker image to be used in development environments (SQLite) and production deployments (PostgreSQL) without modifying application code or rebuilding containers.

### Environment-Based Configuration

The server behavior is controlled entirely through environment variables or an optional mounted configuration file. Key variables include:

- `STORAGE_BACKEND`: Selects the database driver (`sqlite` or `postgres`)
- `SQLITE_DB_PATH`: File system path for SQLite database files
- `POSTGRES_CONNECTION_URL`: Full PostgreSQL connection string including credentials
- `MCP_LOG_LEVEL`: Controls verbosity (`debug`, `info`, `warn`, `error`)

For advanced use cases, you can mount a custom [`mcp.yaml`](https://github.com/Graphify-Labs/graphify/blob/main/mcp.yaml) file to configure indexing options, custom tokenizers, and resource limits (CPU/memory) as noted in [`docs/docker-mcp-sqlite.md`](https://github.com/Graphify-Labs/graphify/blob/main/docs/docker-mcp-sqlite.md).

## Exposed Tools and HTTP Endpoints

The MCP server exposes four primary tools via its HTTP API, each designed for a specific graph management operation.

### Ingest Tool (`POST /api/ingest`)

The `/api/ingest` endpoint accepts JSON payloads containing document batches to be indexed into the knowledge graph. Each document must include an `id`, `title`, and `content` field, with an optional `metadata` object for custom attributes like author and tags.

```bash
curl -X POST http://localhost:8000/api/ingest \
  -H "Content-Type: application/json" \
  -d '[{
    "id": "doc1",
    "title": "Introduction to Graphify",
    "content": "Graphify is a knowledge graph platform...",
    "metadata": {
      "author": "Jane Doe",
      "tags": ["graph", "database"]
    }
  }]'

```

On success, the server returns a confirmation object indicating the number of documents ingested: `{ "status": "success", "ingested": 1 }`.

### Query Tool (`POST /api/query`)

The `/api/query` endpoint executes read operations against the stored graph using either GraphQL syntax or Graphify's custom domain-specific language (DSL). Requests must include a `query` field and optionally a `variables` object for parameterized queries.

```bash
curl -X POST http://localhost:8000/api/query \
  -H "Content-Type: application/json" \
  -d '{
    "query": "{ documents { id title } }",
    "variables": {}
  }'

```

The response contains the query results formatted according to the requested schema, allowing clients to retrieve specific node properties and relationships without fetching the entire graph.

### Export Tool (`GET /api/export`)

The `/api/export` endpoint provides a complete data dump of the knowledge graph in JSON or CSV format. This tool is useful for backups, migrations, or offline analysis.

```bash
curl http://localhost:8000/api/export > graph_export.json

```

Unlike the ingest and query endpoints, the export tool uses HTTP GET and returns the raw data directly in the response body without requiring a request payload.

### Health Check Endpoint (`GET /health`)

The `/health` endpoint provides a simple liveness probe that returns `{ "status": "ok" }` when the server is operational and connected to its storage backend.

```bash
curl http://localhost:8000/health

```

This endpoint is typically used by container orchestrators (Kubernetes, Docker Compose) to verify service readiness before routing traffic to the instance.

## Deployment and Configuration Examples

To run the Graphify MCP server with SQLite storage using Docker, execute the following command from the project root:

```bash
docker run -d \
  --name graphify-mcp \
  -p 8000:8000 \
  -e STORAGE_BACKEND=sqlite \
  -e SQLITE_DB_PATH=/data/graphify.db \
  -e MCP_LOG_LEVEL=info \
  -v $(pwd)/data:/data \
  graphify/mcp:latest

```

For PostgreSQL deployments, replace the SQLite variables with the appropriate connection string:

```bash
docker run -d \
  --name graphify-mcp \
  -p 8000:8000 \
  -e STORAGE_BACKEND=postgres \
  -e POSTGRES_CONNECTION_URL="postgresql://user:password@db-host:5432/graphify" \
  graphify/mcp:latest

```

To use a custom configuration file, mount the [`mcp.yaml`](https://github.com/Graphify-Labs/graphify/blob/main/mcp.yaml) into the container's `/app/config/` directory:

```bash
docker run -d \
  --name graphify-mcp \
  -p 8000:8000 \
  -v $(pwd)/config/mcp.yaml:/app/config/mcp.yaml \
  -v $(pwd)/data:/data \
  graphify/mcp:latest

```

## Summary

- The **Graphify MCP server** is a stateless HTTP service that manages knowledge graph operations via REST endpoints.
- It supports **two storage backends** (SQLite and PostgreSQL) selected via the `STORAGE_BACKEND` environment variable.
- The server exposes **four core tools**: Ingest (`/api/ingest`), Query (`/api/query`), Export (`/api/export`), and Health Check (`/health`).
- Configuration is handled through **environment variables** or an optional [`mcp.yaml`](https://github.com/Graphify-Labs/graphify/blob/main/mcp.yaml) file, making it ideal for containerized deployments.
- Full API specifications are documented in [`docs/mcp-api.md`](https://github.com/Graphify-Labs/graphify/blob/main/docs/mcp-api.md) and [`docs/docker-mcp-sqlite.md`](https://github.com/Graphify-Labs/graphify/blob/main/docs/docker-mcp-sqlite.md) within the Graphify repository.

## Frequently Asked Questions

### What does MCP stand for in Graphify?

MCP stands for **Model Compute Process**. It refers to the server's role as a computational layer that processes model operations (ingestion, querying, and export) on top of the knowledge graph storage backend.

### Can I run the Graphify MCP server without Docker?

While the documentation in [`docs/docker-mcp-sqlite.md`](https://github.com/Graphify-Labs/graphify/blob/main/docs/docker-mcp-sqlite.md) focuses on Docker deployment, the server is designed as a standard HTTP service that can run directly on any system with Python and the required dependencies installed. You would need to set the same environment variables (`STORAGE_BACKEND`, `SQLITE_DB_PATH`, etc.) in your host environment.

### How do I switch from SQLite to PostgreSQL?

Set the `STORAGE_BACKEND` environment variable to `postgres` and provide a valid connection string in `POSTGRES_CONNECTION_URL`. No code changes are required; the server automatically initializes the appropriate database driver on startup according to the configuration in [`docs/mcp-api.md`](https://github.com/Graphify-Labs/graphify/blob/main/docs/mcp-api.md).

### What query languages does the Query tool support?

The `/api/query` endpoint supports both **GraphQL** syntax and Graphify's custom domain-specific language (DSL). You specify the query language in the `query` field of the JSON payload, and the server parses and executes it against the underlying graph engine.