AgentToolHub
Skill

pr-workflow

pr-workflow — a Claude Code skill from tursodatabase/turso

Features

  • ✓In-process SQL database for local development
  • ✓Rust-based, compatible with SQLite
  • ✓MIT licensed, open-source
  • ✓Active community support on Discord
  • ✓Regular updates and contributions
  • ✓Visit GitHub for more tools and details

Installation Guide

Please see the [Turso Database Manual](docs/manual.md) for more information.

<details>
<summary>💻 Command Line</summary>
<br>
You can install the latest turso release with:

shell
curl --proto '=https' --tlsv1.2 -LsSf \
  https://github.com/tursodatabase/turso/releases/latest/download/turso_cli-installer.sh | sh

Then launch the interactive shell:

shell
$ tursodb

This will start the Turso interactive shell where you can execute SQL statements:

console
Turso
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database
turso> CREATE TABLE users (id INT, username TEXT);
turso> INSERT INTO users VALUES (1, 'alice');
turso> INSERT INTO users VALUES (2, 'bob');
turso> SELECT * FROM users;
1|alice
2|bob

You can also build and run the latest development version with:

shell
cargo run

If you like docker, we got you covered. Simply run this in the root folder:

bash
make docker-cli-build && \
make docker-cli-run

</details>

<details>
<summary>🦀 Rust</summary>
<br>

console
cargo add turso

Example usage:

rust
let db = Builder::new_local("sqlite.db").build().await?;
let conn = db.connect()?;

let res = conn.query("SELECT * FROM users", ()).await?;

</details>

<details>
<summary>✨ JavaScript</summary>
<br>

console
npm i @tursodatabase/database

Example usage:

js
import { connect } from '@tursodatabase/database';

const db = await connect('sqlite.db');
const stmt = db.prepare('SELECT * FROM users');
const users = stmt.all();
console.log(users);

</details>

<details>
<summary>🐍 Python</summary>
<br>

console
uv pip install pyturso

Example usage:

python
import turso

con = turso.connect("sqlite.db")
cur = con.cursor()
res = cur.execute("SELECT * FROM users")
print(res.fetchone())

</details>

<details>
<summary>🦫 Go</summary>
<br>

console
go get turso.tech/database/tursogo
go install turso.tech/database/tursogo

Example usage:

go
import (
    "database/sql"
    _ "turso.tech/database/tursogo"
)

conn, _ = sql.Open("turso", "sqlite.db")
defer conn.Close()

stmt, _ := conn.Prepare("select * from users")
defer stmt.Close()

rows, _ = stmt.Query()
for rows.Next() {
    var id int
    var username string
    _ := rows.Scan(&id, &username)
    fmt.Printf("User: ID: %d, Username: %s\n", id, username)
}

</details>

<details>

<summary>️#️⃣ .NET</summary>
<br>

Example usage:

cs
using Turso;

using var connection = new TursoConnection("Data Source=:memory:");
connection.Open();

connection.ExecuteNonQuery("CREATE TABLE t(a, b)");
var rowsAffected = connection.ExecuteNonQuery("INSERT INTO t(a, b) VALUES (1, 2), (3, 4)");
Console.WriteLine($"RowsAffected: {rowsAffected}");

using var command = connection.CreateCommand();
command.CommandText = "SELECT * FROM t";
using var reader = command.ExecuteReader();
while (reader.Read())
{
    var a = reader.GetInt32(0);
    var b = reader.GetInt32(1);
    Console.WriteLine($"Value1: {a}, Value2: {b}");
}

</details>

<details>

<summary>☕️ Java</summary>
<br>

We integrated Turso Database into JDBC. For detailed instructions on how to use Turso Database with java, please refer to
the [README.md under bindings/java](bindings/java/README.md).
</details>

<details>
<summary>🤖 MCP Server Mode</summary>
<br>

The Turso CLI includes a built-in Model Context Protocol (MCP) server that allows AI assistants to interact with your databases.

Start the MCP server with:

shell
tursodb your_database.db --mcp

Configuration

Add Turso to your MCP client configuration:

json
{
  "mcpServers": {
    "turso": {
      "command": "/path/to/.turso/tursodb",
      "args": ["/path/to/your/database.db", "--mcp"]
    }
  }
}

Available Tools

The MCP server provides nine tools for database interaction:

  • open_database - Open a new database

  • current_database - Describe the current database

  • list_tables - List all tables in the database

  • describe_table - Describe the structure of a specific table

  • execute_query - Execute read-only SELECT queries

  • insert_data - Insert new data into tables

  • update_data - Update existing data in tables

  • delete_data - Delete data from tables

  • schema_change - Execute schema modification statements (CREATE TABLE, ALTER TABLE, DROP TABLE)

    • Once connected, you can ask your AI assistant:

  • "Show me all tables in the database"

  • "What's the schema for the users table?"

  • "Find all posts with more than 100 upvotes"

  • "Insert a new user with name 'Alice' and email 'alice@example.com'"

    • MCP Clients

    <details>
    <summary>Claude Code</summary>

    If you're using Claude Code, you can easily connect to your Turso MCP server using the built-in MCP management commands:

    #### Quick Setup

  • Add the MCP server to Claude Code:

    • bash
       claude mcp add my-database -- tursodb ./path/to/your/database.db --mcp

  • Restart Claude Code to activate the connection

  • Start querying your database through natural language!

    • #### Command Breakdown

    bash
    claude mcp add my-database -- tursodb ./path/to/your/database.db --mcp
#              ↑            ↑       ↑                           ↑
#              |            |       |                           |
#              Name         |       Database path               MCP flag
#                          Separator

  • my-database - Choose any name for your MCP server

  • -- - Required separator between Claude options and your command

  • tursodb - The Turso database CLI

  • ./path/to/your/database.db - Path to your SQLite database file

  • --mcp - Enables MCP server mode

    • #### Example Usage

    bash
    # For a local project database
cd /your/project
claude mcp add my-project-db -- tursodb ./data/app.db --mcp

# For an absolute path
claude mcp add analytics-db -- tursodb /Users/you/databases/analytics.db --mcp

# For a specific project (local scope)
claude mcp add project-db --local -- tursodb ./database.db --mcp

    #### Managing MCP Servers

    bash
    # List all configured MCP servers
claude mcp list

# Get details about a specific server
claude mcp get my-database

# Remove an MCP server
claude mcp remove my-database

    </details>

    <details>
    <summary>Claude Desktop</summary>

    For Claude Desktop, add the configuration to your claude_desktop_config.json file:

    json
    {
  "mcpServers": {
    "turso": {
      "command": "/path/to/.turso/tursodb",
      "args": ["./path/to/your/database.db.db", "--mcp"]
    }
  }
}

    </details>

    <details>
    <summary>Cursor</summary>

    For Cursor, configure MCP in your settings:

  • Open Cursor settings

  • Navigate to Extensions → MCP

  • Add a new server with:

    • - Name: turso
    - Command: /path/to/.turso/tursodb
    - Args: ["./path/to/your/database.db.db", "--mcp"]

    Alternatively, you can add it to your Cursor configuration file directly.

    </details>

    Direct JSON-RPC Usage

    The MCP server runs as a single process that handles multiple JSON-RPC requests over stdin/stdout. Here's how to interact with it directly:

    #### Example with In-Memory Database

    bash
    cat << 'EOF' | tursodb --mcp
{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "client", "version": "1.0"}}}
{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "schema_change", "arguments": {"query": "CREATE TABLE users (id INTEGER, name TEXT, email TEXT)"}}}
{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "list_tables", "arguments": {}}}
{"jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "insert_data", "arguments": {"query": "INSERT INTO users VALUES (1, 'Alice', 'alice@example.com')"}}}
{"jsonrpc": "2.0", "id": 5, "method": "tools/call", "params": {"name": "execute_query", "arguments": {"query": "SELECT * FROM users"}}}
EOF

    #### Example with Existing Database

    bash
    # Working with an existing database file
cat << 'EOF' | tursodb mydb.db --mcp
{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "client", "version": "1.0"}}}
{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "list_tables", "arguments": {}}}
EOF

    </details>

    Reviews