Editor Setup

Zed Editor Setup

Learn how to setup Zed editor to work effectively with Tomba API using AI assistance and our comprehensive documentation.

Quick Use

Using Assistant Panel

In Zed's assistant panel, you can reference our documentation:

Code
 
Please fetch the documentation from https://docs.tomba.io/llms.txt and help me create a Rust function for email verification using Tomba API

Direct Web Context

Code
 
Based on the Tomba API documentation at https://docs.tomba.io/llms.txt, generate a Go client for email finding with proper error handling

Project-level Setup

Method 1: Project Documentation

Create a documentation file in your project:

Code
 
# Create docs directory
mkdir -p docs

# Download Tomba API documentation
curl -L https://docs.tomba.io/llms.txt -o docs/tomba-api.md

Method 2: Workspace Configuration

Create a .zed directory with configuration:

Code
 
mkdir -p .zed

Add this to .zed/settings.json:

Code
 
{
    "assistant": {
        "version": "2",
        "default_model": {
            "provider": "anthropic",
            "model": "claude-3-5-sonnet-20241022"
        },
        "custom_instructions": "When working with API code, prioritize Tomba API patterns from docs/tomba-api.md. Use proper authentication headers (X-Tomba-Key, X-Tomba-Secret) and handle rate limiting appropriately."
    },
    "context_servers": [
        {
            "id": "tomba-docs",
            "executable": {
                "command": "cat",
                "args": ["docs/tomba-api.md"]
            }
        }
    ]
}

Zed-Specific Features

1. Language Server Integration

Configure language servers for better API development:

Code
 
{
    "lsp": {
        "rust-analyzer": {
            "cargo": {
                "features": ["tokio", "reqwest", "serde"]
            }
        },
        "typescript-language-server": {
            "settings": {
                "typescript": {
                    "preferences": {
                        "importModuleSpecifier": "relative"
                    }
                }
            }
        }
    }
}

2. Custom Snippets

Create Tomba API snippets in your language settings:

For JavaScript/TypeScript (.zed/snippets/javascript.json):

Code
 
{
    "tomba-email-finder": {
        "prefix": "tomba-finder",
        "body": [
            "async function findEmails(domain) {",
            "  const response = await fetch(`https://api.tomba.io/v1/domain-search?domain=${domain}`, {",
            "    headers: {",
            "      'X-Tomba-Key': process.env.TOMBA_API_KEY,",
            "      'X-Tomba-Secret': process.env.TOMBA_SECRET_KEY",
            "    }",
            "  });",
            "  ",
            "  if (!response.ok) {",
            "    throw new Error(`HTTP error! status: ${response.status}`);",
            "  }",
            "  ",
            "  return await response.json();",
            "}"
        ],
        "description": "Create a Tomba email finder function"
    },
    "tomba-email-verifier": {
        "prefix": "tomba-verify",
        "body": [
            "async function verifyEmail(email) {",
            "  const response = await fetch(`https://api.tomba.io/v1/email-verifier?email=${email}`, {",
            "    headers: {",
            "      'X-Tomba-Key': process.env.TOMBA_API_KEY,",
            "      'X-Tomba-Secret': process.env.TOMBA_SECRET_KEY",
            "    }",
            "  });",
            "  ",
            "  if (!response.ok) {",
            "    throw new Error(`HTTP error! status: ${response.status}`);",
            "  }",
            "  ",
            "  return await response.json();",
            "}"
        ],
        "description": "Create a Tomba email verifier function"
    }
}

For Rust (.zed/snippets/rust.json):

Code
 
{
    "tomba-client": {
        "prefix": "tomba-client",
        "body": [
            "use reqwest::Client;",
            "use serde_json::Value;",
            "use std::collections::HashMap;",
            "",
            "pub struct TombaClient {",
            "    client: Client,",
            "    api_key: String,",
            "    secret_key: String,",
            "}",
            "",
            "impl TombaClient {",
            "    pub fn new(api_key: String, secret_key: String) -> Self {",
            "        Self {",
            "            client: Client::new(),",
            "            api_key,",
            "            secret_key,",
            "        }",
            "    }",
            "",
            "    pub async fn domain_search(&self, domain: &str) -> Result<Value, reqwest::Error> {",
            "        let url = format!(\"https://api.tomba.io/v1/domain-search?domain={}\", domain);",
            "        ",
            "        let response = self.client",
            "            .get(&url)",
            "            .header(\"X-Tomba-Key\", &self.api_key)",
            "            .header(\"X-Tomba-Secret\", &self.secret_key)",
            "            .send()",
            "            .await?;",
            "        ",
            "        response.json().await",
            "    }",
            "}"
        ],
        "description": "Create a Tomba API client in Rust"
    }
}

Configuration Examples

Rust Development

For Rust projects, add this to your Cargo.toml:

Code
 
[dependencies]
reqwest = { version = "0.11", features = ["json"] }
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
anyhow = "1.0"

Then use the assistant:

Code
 
Using the Tomba API documentation, create a complete Rust library for email finding and verification with proper error handling and async support

Go Development

For Go projects, initialize modules:

Code
 
go mod init tomba-client
go get github.com/go-resty/resty/v2

Assistant prompt:

Code
 
Based on the Tomba API docs, create a Go package for email operations using the resty HTTP client with proper struct definitions and error handling

Python Development

Setup virtual environment:

Code
 
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install requests aiohttp

Assistant prompt:

Code
 
Using Tomba API documentation, create a Python async client class with both sync and async methods for all email operations

Example Use Cases

1. Multi-language API Client

Prompt:

Code
 
Based on docs/tomba-api.md, create API clients in Rust, Go, and Python that all follow the same interface pattern for email finding and verification

2. CLI Tool Development

Prompt:

Code
 
Using the Tomba API documentation, create a CLI tool in Rust using clap that can:
- Find emails for a domain
- Verify single emails
- Bulk verify from a file
- Export results to JSON/CSV

3. Web Service Integration

Prompt:

Code
 
Create a microservice using the Tomba API that provides:
- REST endpoints for email operations
- Rate limiting middleware
- Caching with Redis
- Proper logging and metrics

Advanced Configuration

Environment Variables

Create a .env.example file:

Code
 
# Tomba API Configuration
TOMBA_API_KEY=your_api_key_here
TOMBA_SECRET_KEY=your_secret_key_here
TOMBA_BASE_URL=https://api.tomba.io/v1

# Optional Configuration
TOMBA_TIMEOUT=30
TOMBA_RATE_LIMIT=100

Project Templates

Create project templates for common Tomba integrations:

Code
 
# Create templates directory
mkdir -p .zed/templates

# Rust API client template
cat > .zed/templates/rust-tomba-client.rs << 'EOF'
// Tomba API Client Template
use reqwest::Client;
use serde::{Deserialize, Serialize};
use std::time::Duration;

#[derive(Debug, Clone)]
pub struct TombaClient {
    client: Client,
    api_key: String,
    secret_key: String,
    base_url: String,
}

// Add your implementation here
EOF

Task Configuration

Add build and test tasks to .zed/tasks.json:

Code
 
{
    "tasks": [
        {
            "label": "Build Tomba Client",
            "command": "cargo",
            "args": ["build", "--release"],
            "group": "build"
        },
        {
            "label": "Test Tomba Integration",
            "command": "cargo",
            "args": ["test", "--", "--nocapture"],
            "group": "test"
        },
        {
            "label": "Run Examples",
            "command": "cargo",
            "args": ["run", "--example", "email_finder"],
            "group": "build"
        }
    ]
}

Best Practices

1. Structured Prompts

Use clear, structured prompts:

Code
 
Context: Building a Rust application that processes user signups
Task: Integrate Tomba email verification
Requirements:
- Async/await pattern
- Proper error handling with custom error types
- Rate limiting with exponential backoff
- Comprehensive tests

2. Incremental Development

Build features incrementally:

Code
 
Step 1: Create basic Tomba client struct
Step 2: Add email verification method
Step 3: Add error handling
Step 4: Add rate limiting
Step 5: Add caching layer

3. Code Review Integration

Use Zed's collaborative features:

Code
 
Review this Tomba API integration for:
- Security best practices
- Error handling completeness
- Performance optimizations
- Code documentation

Troubleshooting

Assistant Not Responding

Check your API keys in Zed settings
Verify internet connection
Try restarting Zed
Clear assistant cache if available

Documentation Not Found

Ensure docs/tomba-api.md exists in your project
Check file permissions
Verify the curl command downloaded the file correctly

Build Issues

Check language server status in Zed
Verify dependencies are correctly installed
Review compiler/interpreter error messages

Additional Resources

Last modified on October 2, 2025

Cursor Setup Windsurf Setup