Database on Producthunt daily

monad

Fri, 19 Sep 2025 15:27:28 +0800

category-labs/monad

Monad Execution

Overview

This repository contains the execution component of a Monad node. It handles the transaction processing for new blocks, and keeps track of the state of the blockchain. Consequently, this repository contains the source code for Category Labs’ custom EVM implementation, its database implementation, and the high-level transaction scheduling. The other main repository is monad-bft, which contains the source code for the consensus component.

Building the source code

Package requirements

Execution has two kinds of dependencies on third-party libraries:

Self-managed: execution’s CMake build system will checkout most of its third-party dependencies as git submodules, and build them as part of its own build process, as CMake subprojects; this will happen automatically during the build, but you must run:
1

git submodule update --init --recursive
after checking out this repository.
System: some dependencies are expected to already be part of the system in a default location, i.e., they are expected to come from the system’s package manager. The primary development platform is Ubuntu, so the required packages use the Debian/Ubuntu package names; an up-to-date list of the required system dependencies can be found in the docker configuration file docker/release.Dockerfile (you will need all the packages installed via the apt install commands)

Minimum development tool requirements

gcc-15 or clang-19
CMake 3.27
Even when using clang, the only standard library supported is libstdc++; libc++ may work but it is not a tested platform

CPU compilation requirements

As explained in the hardware requirements, a Monad node requires a relatively recent CPU. Execution explicitly requires this to compile: it needs to emit machine code that is only supported on recent CPU models, for fast cryptographic operations.

The minimum ISA support corresponds to the x86-64-v3 feature level. Consequently, the minimum flag you must pass to the compiler is -march=x86-64-v3, or alternatively -march=haswell (“Haswell” was the codename of the first Intel CPU to support all of these features).

You may also pass any higher architecture level if you wish, although the compiled binary may not work on older CPUs. The execution docker files use -march=haswell because it tries to maximize the number of systems the resulting binary can run on. If you are only running locally (i.e., the binary does not need to run anywhere else) use -march=native.

Compiling the execution code

First, change your working directory to the root directory of the execution git repository root and then run:

1
2

CC=gcc-15 CXX=g++-15 CFLAGS="-march=haswell" CXXFLAGS="-march=haswell" ASMFLAGS="-march=haswell" \
./scripts/configure.sh && ./scripts/build.sh

The above command will do several things:

Use gcc-15 instead of the system’s default compiler
Emit machine code using Haswell-era CPU extensions
Run CMake, and generate a ninja build system in the <path-to-execution-repo>/build directory with the CMAKE_BUILD_TYPE set to RelWithDebInfo by default
Build the CMake all target, which builds everything

The compiler and CPU options are injected via environment variables that are read by CMake. If you want debug binaries instead, you can also pass CMAKE_BUILD_TYPE=Debug via the environment.

When finished, this will build all of the execution binaries. The main one is the execution daemon, build/cmd/monad. This binary can provide block execution services for different EVM-compatible blockchains:

When used as part of a Monad blockchain node, it behaves as the block execution service for the Category Labs consensus daemon (for details, see here); when running in this mode, Monad EVM extensions (e.g., Monad-style staking) are enabled
It can also replay the history of other EVM-compatible blockchains, by executing their historical blocks as inputs; a common developer workflow (and a good full system test) is to replay the history of the original Ethereum mainnet and verify that the computed Merkle roots match after each block

You can also run the full test suite in parallel with:

`1`	`CTEST_PARALLEL_LEVEL=$(nproc) ctest`

A tour of execution

To understand how the source code is organized, you should start by reading the execution developer overview, which explains how execution and consensus fit together, and where in the source tree you can find different pieces of functionality.

n8n-workflows

Tue, 16 Sep 2025 15:28:58 +0800

Zie619/n8n-workflows

⚡ N8N Workflow Collection & Documentation

A professionally organized collection of 2,053 n8n workflows with a lightning-fast documentation system that provides instant search, analysis, and browsing capabilities.

⚠️ IMPORTANT NOTICE (Aug 14, 2025): Repository history has been rewritten due to DMCA compliance. If you have a fork or local clone, please see Issue #X for instructions on syncing your copy.

Support My Work

If you’d like to say thanks, consider buying me a coffee—your support helps me keep improving this project!

🚀 NEW: High-Performance Documentation System

Experience 100x performance improvement over traditional documentation!

Quick Start - Fast Documentation System

# Install dependencies
pip install -r requirements.txt

# Start the fast API server
python run.py

# Open in browser
http://localhost:8000

Features:

⚡ Sub-100ms response times with SQLite FTS5 search
🔍 Instant full-text search with advanced filtering
📱 Responsive design - works perfectly on mobile
🌙 Dark/light themes with system preference detection
📊 Live statistics - 365 unique integrations, 29,445 total nodes
🎯 Smart categorization by trigger type and complexity
🎯 Use case categorization by service name mapped to categories
📄 On-demand JSON viewing and download
🔗 Mermaid diagram generation for workflow visualization
🔄 Real-time workflow naming with intelligent formatting

Performance Comparison

Metric	Old System	New System	Improvement
File Size	71MB HTML	<100KB	700x smaller
Load Time	10+ seconds	<1 second	10x faster
Search	Client-side only	Full-text with FTS5	Instant
Memory Usage	~2GB RAM	<50MB RAM	40x less
Mobile Support	Poor	Excellent	Fully responsive

📂 Repository Organization

Workflow Collection

2,053 workflows with meaningful, searchable names
365 unique integrations across popular platforms
29,445 total nodes with professional categorization
Quality assurance - All workflows analyzed and categorized

Advanced Naming System ✨

Our intelligent naming system converts technical filenames into readable titles:

Before: 2051_Telegram_Webhook_Automation_Webhook.json
After: Telegram Webhook Automation
100% meaningful names with smart capitalization
Automatic integration detection from node analysis

Use Case Category ✨

The search interface includes a dropdown filter that lets you browse 2,000+ workflows by category.

The system includes an automated categorization feature that organizes workflows by service categories to make them easier to discover and filter.

How Categorization Works

Run the categorization script
1

python create_categories.py
Service Name Recognition The script analyzes each workflow JSON filename to identify recognized service names (e.g., “Twilio”, “Slack”, “Gmail”, etc.)
Category Mapping Each recognized service name is matched to its corresponding category using the definitions in context/def_categories.json. For example:
- Twilio → Communication & Messaging
- Gmail → Communication & Messaging
- Airtable → Data Processing & Analysis
- Salesforce → CRM & Sales
Search Categories Generation The script produces a search_categories.json file that contains the categorized workflow data
Filter Interface Users can then filter workflows by category in the search interface, making it easier to find workflows for specific use cases

Available Categories

The categorization system includes the following main categories:

AI Agent Development
Business Process Automation
Cloud Storage & File Management
Communication & Messaging
Creative Content & Video Automation
Creative Design Automation
CRM & Sales
Data Processing & Analysis
E-commerce & Retail
Financial & Accounting
Marketing & Advertising Automation
Project Management
Social Media Management
Technical Infrastructure & DevOps
Web Scraping & Data Extraction

Contribute Categories

You can help expand the categorization by adding more service-to-category mappings (e.g., Twilio → Communication & Messaging) in context/defs_categories.json.

Many workflow JSON files are conveniently named with the service name, often separated by underscores (_).

🛠 Usage Instructions

Option 1: Modern Fast System (Recommended)

# Clone repository
git clone <repo-url>
cd n8n-workflows

# Install Python dependencies
pip install -r requirements.txt

# Start the documentation server
python run.py

# Browse workflows at http://localhost:8000
# - Instant search across 2,053 workflows
# - Professional responsive interface
# - Real-time workflow statistics

Option 2: Development Mode

# Start with auto-reload for development
python run.py --dev

# Or specify custom host/port
python run.py --host 0.0.0.0 --port 3000

# Force database reindexing
python run.py --reindex

Import Workflows into n8n

# Use the Python importer (recommended)
python import_workflows.py

# Or manually import individual workflows:
# 1. Open your n8n Editor UI
# 2. Click menu (☰) → Import workflow
# 3. Choose any .json file from the workflows/ folder
# 4. Update credentials/webhook URLs before running

📊 Workflow Statistics

Current Collection Stats

Total Workflows: 2,053 automation workflows
Active Workflows: 215 (10.5% active rate)
Total Nodes: 29,445 (avg 14.3 nodes per workflow)
Unique Integrations: 365 different services and APIs
Database: SQLite with FTS5 full-text search

Trigger Distribution

Complex: 831 workflows (40.5%) - Multi-trigger systems
Webhook: 519 workflows (25.3%) - API-triggered automations
Manual: 477 workflows (23.2%) - User-initiated workflows
Scheduled: 226 workflows (11.0%) - Time-based executions

Complexity Analysis

Low (≤5 nodes): ~35% - Simple automations
Medium (6-15 nodes): ~45% - Standard workflows
High (16+ nodes): ~20% - Complex enterprise systems

Popular Integrations

Top services by usage frequency:

Communication: Telegram, Discord, Slack, WhatsApp
Cloud Storage: Google Drive, Google Sheets, Dropbox
Databases: PostgreSQL, MySQL, MongoDB, Airtable
AI/ML: OpenAI, Anthropic, Hugging Face
Development: HTTP Request, Webhook, GraphQL

🔍 Advanced Search Features

Smart Search Categories

Our system automatically categorizes workflows into 12 service categories:

Available Categories:

messaging: Telegram, Discord, Slack, WhatsApp, Teams
ai_ml: OpenAI, Anthropic, Hugging Face
database: PostgreSQL, MySQL, MongoDB, Redis, Airtable
email: Gmail, Mailjet, Outlook, SMTP/IMAP
cloud_storage: Google Drive, Google Docs, Dropbox, OneDrive
project_management: Jira, GitHub, GitLab, Trello, Asana
social_media: LinkedIn, Twitter/X, Facebook, Instagram
ecommerce: Shopify, Stripe, PayPal
analytics: Google Analytics, Mixpanel
calendar_tasks: Google Calendar, Cal.com, Calendly
forms: Typeform, Google Forms, Form Triggers
development: Webhook, HTTP Request, GraphQL, SSE

API Usage Examples

# Search workflows by text
curl "http://localhost:8000/api/workflows?q=telegram+automation"

# Filter by trigger type and complexity
curl "http://localhost:8000/api/workflows?trigger=Webhook&complexity=high"

# Find all messaging workflows
curl "http://localhost:8000/api/workflows/category/messaging"

# Get database statistics
curl "http://localhost:8000/api/stats"

# Browse available categories
curl "http://localhost:8000/api/categories"

🏗 Technical Architecture

Modern Stack

SQLite Database - FTS5 full-text search with 365 indexed integrations
FastAPI Backend - RESTful API with automatic OpenAPI documentation
Responsive Frontend - Modern HTML5 with embedded CSS/JavaScript
Smart Analysis - Automatic workflow categorization and naming

Key Features

Change Detection - MD5 hashing for efficient re-indexing
Background Processing - Non-blocking workflow analysis
Compressed Responses - Gzip middleware for optimal speed
Error Handling - Graceful degradation and comprehensive logging
Mobile Optimization - Touch-friendly interface design

Database Performance

-- Optimized schema for lightning-fast queries
CREATE TABLE workflows (
    id INTEGER PRIMARY KEY,
    filename TEXT UNIQUE,
    name TEXT,
    active BOOLEAN,
    trigger_type TEXT,
    complexity TEXT,
    node_count INTEGER,
    integrations TEXT,  -- JSON array of 365 unique services
    description TEXT,
    file_hash TEXT,     -- MD5 for change detection
    analyzed_at TIMESTAMP
);

-- Full-text search with ranking
CREATE VIRTUAL TABLE workflows_fts USING fts5(
    filename, name, description, integrations, tags,
    content='workflows', content_rowid='id'
);

🔧 Setup & Requirements

System Requirements

Python 3.7+ - For running the documentation system
Modern Browser - Chrome, Firefox, Safari, Edge
50MB Storage - For SQLite database and indexes
n8n Instance - For importing and running workflows

Installation

# Clone repository
git clone <repo-url>
cd n8n-workflows

# Install dependencies
pip install -r requirements.txt

# Start documentation server
python run.py

# Access at http://localhost:8000

Development Setup

# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate  # Linux/Mac
# or .venv\Scripts\activate  # Windows

# Install dependencies
pip install -r requirements.txt

# Run with auto-reload for development
python api_server.py --reload

# Force database reindexing
python workflow_db.py --index --force

📋 Naming Convention

Intelligent Formatting System

Our system automatically converts technical filenames to user-friendly names:

# Automatic transformations:
2051_Telegram_Webhook_Automation_Webhook.json → "Telegram Webhook Automation"
0250_HTTP_Discord_Import_Scheduled.json → "HTTP Discord Import Scheduled"  
0966_OpenAI_Data_Processing_Manual.json → "OpenAI Data Processing Manual"

Technical Format

`1`	`[ID]_[Service1]_[Service2]_[Purpose]_[Trigger].json`

Smart Capitalization Rules

HTTP → HTTP (not Http)
API → API (not Api)
webhook → Webhook
automation → Automation
scheduled → Scheduled

🚀 API Documentation

Core Endpoints

GET / - Main workflow browser interface
GET /api/stats - Database statistics and metrics
GET /api/workflows - Search with filters and pagination
GET /api/workflows/{filename} - Detailed workflow information
GET /api/workflows/{filename}/download - Download workflow JSON
GET /api/workflows/{filename}/diagram - Generate Mermaid diagram

Advanced Search

GET /api/workflows/category/{category} - Search by service category
GET /api/categories - List all available categories
GET /api/integrations - Get integration statistics
POST /api/reindex - Trigger background reindexing

Response Examples

// GET /api/stats
{
  "total": 2053,
  "active": 215,
  "inactive": 1838,
  "triggers": {
    "Complex": 831,
    "Webhook": 519,
    "Manual": 477,
    "Scheduled": 226
  },
  "total_nodes": 29445,
  "unique_integrations": 365
}

🤝 Contributing

Adding New Workflows

Export workflow as JSON from n8n
Name descriptively following the established pattern
Add to workflows/ directory
Remove sensitive data (credentials, personal URLs)
Run reindexing to update the database

Quality Standards

✅ Workflow must be functional and tested
✅ Remove all credentials and sensitive data
✅ Follow naming convention for consistency
✅ Verify compatibility with recent n8n versions
✅ Include meaningful description or comments

⚠️ Important Notes

Security & Privacy

Review before use - All workflows shared as-is for educational purposes
Update credentials - Replace API keys, tokens, and webhooks
Test safely - Verify in development environment first
Check permissions - Ensure proper access rights for integrations

Compatibility

n8n Version - Compatible with n8n 1.0+ (most workflows)
Community Nodes - Some workflows may require additional node installations
API Changes - External services may have updated their APIs since creation
Dependencies - Verify required integrations before importing

📚 Resources & References

Workflow Sources

This comprehensive collection includes workflows from:

Official n8n.io - Documentation and community examples
GitHub repositories - Open source community contributions
Blog posts & tutorials - Real-world automation patterns
User submissions - Tested and verified workflows
Enterprise use cases - Business process automations

Learn More

n8n Documentation - Official documentation
n8n Community - Community forum and support
Workflow Templates - Official template library
Integration Docs - Service-specific guides

🏆 Project Achievements

Repository Transformation

2,053 workflows professionally organized and named
365 unique integrations automatically detected and categorized
100% meaningful names (improved from basic filename patterns)
Zero data loss during intelligent renaming process
Advanced search with 12 service categories

Performance Revolution

Sub-100ms search with SQLite FTS5 full-text indexing
Instant filtering across 29,445 workflow nodes
Mobile-optimized responsive design for all devices
Real-time statistics with live database queries
Professional interface with modern UX principles

System Reliability

Robust error handling with graceful degradation
Change detection for efficient database updates
Background processing for non-blocking operations
Comprehensive logging for debugging and monitoring
Production-ready with proper middleware and security

This repository represents the most comprehensive and well-organized collection of n8n workflows available, featuring cutting-edge search technology and professional documentation that makes workflow discovery and usage a delightful experience.

🎯 Perfect for: Developers, automation engineers, business analysts, and anyone looking to streamline their workflows with proven n8n automations.

中文

pocketbase

Fri, 05 Sep 2025 15:27:59 +0800

pocketbase/pocketbase

PocketBase is an open source Go backend that includes:

embedded database (SQLite) with realtime subscriptions
built-in files and users management
convenient Admin dashboard UI
and simple REST-ish API

For documentation and examples, please visit https://pocketbase.io/docs.

[!WARNING] Please keep in mind that PocketBase is still under active development and therefore full backward compatibility is not guaranteed before reaching v1.0.0.

API SDK clients

The easiest way to interact with the PocketBase Web APIs is to use one of the official SDK clients:

JavaScript - pocketbase/js-sdk (Browser, Node.js, React Native)
Dart - pocketbase/dart-sdk (Web, Mobile, Desktop, CLI)

You could also check the recommendations in https://pocketbase.io/docs/how-to-use/.

Overview

Use as standalone app

You could download the prebuilt executable for your platform from the Releases page. Once downloaded, extract the archive and run ./pocketbase serve in the extracted directory.

The prebuilt executables are based on the examples/base/main.go file and comes with the JS VM plugin enabled by default which allows to extend PocketBase with JavaScript (for more details please refer to Extend with JavaScript).

Use as a Go framework/toolkit

PocketBase is distributed as a regular Go library package which allows you to build your own custom app specific business logic and still have a single portable executable at the end.

Here is a minimal example:

Install Go 1.23+ (if you haven’t already)

Create a new project directory with the following main.go file inside it:

package main

import (
    "log"

    "github.com/pocketbase/pocketbase"
    "github.com/pocketbase/pocketbase/core"
)

func main() {
    app := pocketbase.New()

    app.OnServe().BindFunc(func(se *core.ServeEvent) error {
        // registers new "GET /hello" route
        se.Router.GET("/hello", func(re *core.RequestEvent) error {
            return re.String(200, "Hello world!")
        })

        return se.Next()
    })

    if err := app.Start(); err != nil {
        log.Fatal(err)
    }
}

To init the dependencies, run go mod init myapp && go mod tidy.
To start the application, run go run main.go serve.
To build a statically linked executable, you can run CGO_ENABLED=0 go build and then start the created executable with ./myapp serve.

For more details please refer to Extend with Go.

Building and running the repo main.go example

To build the minimal standalone executable, like the prebuilt ones in the releases page, you can simply run go build inside the examples/base directory:

Install Go 1.23+ (if you haven’t already)
Clone/download the repo
Navigate to examples/base
Run GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build (https://go.dev/doc/install/source#environment)
Start the created executable by running ./base serve.

Note that the supported build targets by the pure Go SQLite driver at the moment are:

darwin  amd64
darwin  arm64
freebsd amd64
freebsd arm64
linux   386
linux   amd64
linux   arm
linux   arm64
linux   ppc64le
linux   riscv64
linux   s390x
windows amd64
windows arm64

Testing

PocketBase comes with mixed bag of unit and integration tests. To run them, use the standard go test command:

`1`	`go test ./...`

Check also the Testing guide to learn how to write your own custom application tests.

Security

If you discover a security vulnerability within PocketBase, please send an e-mail to support at pocketbase.io.

All reports will be promptly addressed and you’ll be credited in the fix release notes.

Contributing

PocketBase is free and open source project licensed under the MIT License. You are free to do whatever you want with it, even offering it as a paid service.

You could help continuing its development by:

PRs for new OAuth2 providers, bug fixes, code optimizations and documentation improvements are more than welcome.

But please refrain creating PRs for new features without previously discussing the implementation details. PocketBase has a roadmap and I try to work on issues in specific order and such PRs often come in out of nowhere and skew all initial planning with tedious back-and-forth communication.

Don’t get upset if I close your PR, even if it is well executed and tested. This doesn’t mean that it will never be merged. Later we can always refer to it and/or take pieces of your implementation when the time comes to work on the issue (don’t worry you’ll be credited in the release notes).

genai-toolbox

Thu, 28 Aug 2025 15:29:14 +0800

googleapis/genai-toolbox

MCP Toolbox for Databases

[!NOTE] MCP Toolbox for Databases is currently in beta, and may see breaking changes until the first stable release (v1.0).

MCP Toolbox for Databases is an open source MCP server for databases. It enables you to develop tools easier, faster, and more securely by handling the complexities such as connection pooling, authentication, and more.

This README provides a brief overview. For comprehensive details, see the full documentation.

[!NOTE] This solution was originally named “Gen AI Toolbox for Databases” as its initial development predated MCP, but was renamed to align with recently added MCP compatibility.

Why Toolbox?

Toolbox helps you build Gen AI tools that let your agents access data in your database. Toolbox provides:

Simplified development: Integrate tools to your agent in less than 10 lines of code, reuse tools between multiple agents or frameworks, and deploy new versions of tools more easily.
Better performance: Best practices such as connection pooling, authentication, and more.
Enhanced security: Integrated auth for more secure access to your data
End-to-end observability: Out of the box metrics and tracing with built-in support for OpenTelemetry.

⚡ Supercharge Your Workflow with an AI Database Assistant ⚡

Stop context-switching and let your AI assistant become a true co-developer. By connecting your IDE to your databases with MCP Toolbox, you can delegate complex and time-consuming database tasks, allowing you to build faster and focus on what matters. This isn’t just about code completion; it’s about giving your AI the context it needs to handle the entire development lifecycle.

Here’s how it will save you time:

Query in Plain English: Interact with your data using natural language right from your IDE. Ask complex questions like, “How many orders were delivered in 2024, and what items were in them?” without writing any SQL.
Automate Database Management: Simply describe your data needs, and let the AI assistant manage your database for you. It can handle generating queries, creating tables, adding indexes, and more.
Generate Context-Aware Code: Empower your AI assistant to generate application code and tests with a deep understanding of your real-time database schema. This accelerates the development cycle by ensuring the generated code is directly usable.
Slash Development Overhead: Radically reduce the time spent on manual setup and boilerplate. MCP Toolbox helps streamline lengthy database configurations, repetitive code, and error-prone schema migrations.

Learn how to connect your AI tools (IDEs) to Toolbox using MCP.

General Architecture

Toolbox sits between your application’s orchestration framework and your database, providing a control plane that is used to modify, distribute, or invoke tools. It simplifies the management of your tools by providing you with a centralized location to store and update tools, allowing you to share tools between agents and applications and update those tools without necessarily redeploying your application.

Getting Started

Installing the server

For the latest version, check the releases page and use the following instructions for your OS and CPU architecture.

Binary

To install Toolbox as a binary:

# see releases page for other versions
export VERSION=0.13.0
curl -O https://storage.googleapis.com/genai-toolbox/v$VERSION/linux/amd64/toolbox
chmod +x toolbox

Container image

You can also install Toolbox as a container:

1
2
3

# see releases page for other versions
export VERSION=0.13.0
docker pull us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$VERSION

Homebrew

To install Toolbox using Homebrew on macOS or Linux:

`1`	`brew install mcp-toolbox`

Compile from source

To install from source, ensure you have the latest version of Go installed, and then run the following command:

`1`	`go install github.com/googleapis/genai-toolbox@v0.13.0`

Running the server

Configure a tools.yaml to define your tools, and then execute toolbox to start the server:

`1`	`./toolbox --tools-file "tools.yaml"`

[!NOTE] Toolbox enables dynamic reloading by default. To disable, use the --disable-reload flag.

Homebrew Users

If you installed Toolbox using Homebrew, the toolbox binary is available in your system path. You can start the server with the same command:

`1`	`toolbox --tools-file "tools.yaml"`

You can use toolbox help for a full list of flags! To stop the server, send a terminate signal (ctrl+c on most platforms).

For more detailed documentation on deploying to different environments, check out the resources in the How-to section

Integrating your application

Once your server is up and running, you can load the tools into your application. See below the list of Client SDKs for using various frameworks:

Python (Github)

Core

Install Toolbox Core SDK:
1

pip install toolbox-core

Load tools:

from toolbox_core import ToolboxClient

# update the url to point to your server
async with ToolboxClient("http://127.0.0.1:5000") as client:

    # these tools can be passed to your application!
    tools = await client.load_toolset("toolset_name")

For more detailed instructions on using the Toolbox Core SDK, see the project’s README.

LangChain / LangGraph

Install Toolbox LangChain SDK:
1

pip install toolbox-langchain

Load tools:

from toolbox_langchain import ToolboxClient

# update the url to point to your server
async with ToolboxClient("http://127.0.0.1:5000") as client:

    # these tools can be passed to your application!
    tools = client.load_toolset()

For more detailed instructions on using the Toolbox LangChain SDK, see the project’s README.

LlamaIndex

Install Toolbox Llamaindex SDK:
1

pip install toolbox-llamaindex

Load tools:

from toolbox_llamaindex import ToolboxClient

# update the url to point to your server
async with ToolboxClient("http://127.0.0.1:5000") as client:

    # these tools can be passed to your application!
    tools = client.load_toolset()

For more detailed instructions on using the Toolbox Llamaindex SDK, see the project’s README.

Javascript/Typescript (Github)

Core

Install Toolbox Core SDK:
1

npm install @toolbox-sdk/core

Load tools:

import { ToolboxClient } from '@toolbox-sdk/core';

// update the url to point to your server
const URL = 'http://127.0.0.1:5000';
let client = new ToolboxClient(URL);

// these tools can be passed to your application!
const tools = await client.loadToolset('toolsetName');

For more detailed instructions on using the Toolbox Core SDK, see the project’s README.

LangChain / LangGraph

Install Toolbox Core SDK:
1

npm install @toolbox-sdk/core

Load tools:

import { ToolboxClient } from '@toolbox-sdk/core';

// update the url to point to your server
const URL = 'http://127.0.0.1:5000';
let client = new ToolboxClient(URL);

// these tools can be passed to your application!
const toolboxTools = await client.loadToolset('toolsetName');

// Define the basics of the tool: name, description, schema and core logic
const getTool = (toolboxTool) => tool(currTool, {
    name: toolboxTool.getName(),
    description: toolboxTool.getDescription(),
    schema: toolboxTool.getParamSchema()
});

// Use these tools in your Langchain/Langraph applications
const tools = toolboxTools.map(getTool);

Genkit

Install Toolbox Core SDK:
1

npm install @toolbox-sdk/core

Load tools:

import { ToolboxClient } from '@toolbox-sdk/core';
import { genkit } from 'genkit';

// Initialise genkit
const ai = genkit({
    plugins: [
        googleAI({
            apiKey: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY
        })
    ],
    model: googleAI.model('gemini-2.0-flash'),
});

// update the url to point to your server
const URL = 'http://127.0.0.1:5000';
let client = new ToolboxClient(URL);

// these tools can be passed to your application!
const toolboxTools = await client.loadToolset('toolsetName');

// Define the basics of the tool: name, description, schema and core logic
const getTool = (toolboxTool) => ai.defineTool({
    name: toolboxTool.getName(),
    description: toolboxTool.getDescription(),
    schema: toolboxTool.getParamSchema()
}, toolboxTool)

// Use these tools in your Genkit applications
const tools = toolboxTools.map(getTool);

Go (Github)

Core

Install Toolbox Go SDK:

`1`	`go get github.com/googleapis/mcp-toolbox-sdk-go`

Load tools:

package main

import (
  "github.com/googleapis/mcp-toolbox-sdk-go/core"
  "context"
)

func main() {
  // Make sure to add the error checks
  // update the url to point to your server
  URL := "http://127.0.0.1:5000";
  ctx := context.Background()

  client, err := core.NewToolboxClient(URL)

  // Framework agnostic tools
  tools, err := client.LoadToolset("toolsetName", ctx)
}

For more detailed instructions on using the Toolbox Go SDK, see the project’s README.

LangChain Go

Install Toolbox Go SDK:

`1`	`go get github.com/googleapis/mcp-toolbox-sdk-go`

Load tools:

package main

import (
  "context"
  "encoding/json"

  "github.com/googleapis/mcp-toolbox-sdk-go/core"
  "github.com/tmc/langchaingo/llms"
)

func main() {
  // Make sure to add the error checks
  // update the url to point to your server
  URL := "http://127.0.0.1:5000"
  ctx := context.Background()

  client, err := core.NewToolboxClient(URL)

  // Framework agnostic tool
  tool, err := client.LoadTool("toolName", ctx)

  // Fetch the tool's input schema
  inputschema, err := tool.InputSchema()

  var paramsSchema map[string]any
  _ = json.Unmarshal(inputschema, &paramsSchema)

  // Use this tool with LangChainGo
  langChainTool := llms.Tool{
    Type: "function",
    Function: &llms.FunctionDefinition{
      Name:        tool.Name(),
      Description: tool.Description(),
      Parameters:  paramsSchema,
    },
  }
}

Genkit

Install Toolbox Go SDK:

`1`	`go get github.com/googleapis/mcp-toolbox-sdk-go`

Load tools:

package main
import (
  "context"
  "encoding/json"

  "github.com/firebase/genkit/go/ai"
  "github.com/firebase/genkit/go/genkit"
  "github.com/googleapis/mcp-toolbox-sdk-go/core"
  "github.com/googleapis/mcp-toolbox-sdk-go/tbgenkit"
  "github.com/invopop/jsonschema"
)

func main() {
  // Make sure to add the error checks
  // Update the url to point to your server
  URL := "http://127.0.0.1:5000"
  ctx := context.Background()
  g, err := genkit.Init(ctx)

  client, err := core.NewToolboxClient(URL)

  // Framework agnostic tool
  tool, err := client.LoadTool("toolName", ctx)

  // Convert the tool using the tbgenkit package
  // Use this tool with Genkit Go
  genkitTool, err := tbgenkit.ToGenkitTool(tool, g)
  if err != nil {
    log.Fatalf("Failed to convert tool: %v\n", err)
  }
}

Go GenAI

Install Toolbox Go SDK:

`1`	`go get github.com/googleapis/mcp-toolbox-sdk-go`

Load tools:

package main

import (
  "context"
  "encoding/json"

  "github.com/googleapis/mcp-toolbox-sdk-go/core"
  "google.golang.org/genai"
)

func main() {
  // Make sure to add the error checks
  // Update the url to point to your server
  URL := "http://127.0.0.1:5000"
  ctx := context.Background()

  client, err := core.NewToolboxClient(URL)

  // Framework agnostic tool
  tool, err := client.LoadTool("toolName", ctx)

  // Fetch the tool's input schema
  inputschema, err := tool.InputSchema()

  var schema *genai.Schema
  _ = json.Unmarshal(inputschema, &schema)

  funcDeclaration := &genai.FunctionDeclaration{
    Name:        tool.Name(),
    Description: tool.Description(),
    Parameters:  schema,
  }

  // Use this tool with Go GenAI
  genAITool := &genai.Tool{
    FunctionDeclarations: []*genai.FunctionDeclaration{funcDeclaration},
  }
}

OpenAI Go

Install Toolbox Go SDK:

`1`	`go get github.com/googleapis/mcp-toolbox-sdk-go`

Load tools:

package main

import (
  "context"
  "encoding/json"

  "github.com/googleapis/mcp-toolbox-sdk-go/core"
  openai "github.com/openai/openai-go"
)

func main() {
  // Make sure to add the error checks
  // Update the url to point to your server
  URL := "http://127.0.0.1:5000"
  ctx := context.Background()

  client, err := core.NewToolboxClient(URL)

  // Framework agnostic tool
  tool, err := client.LoadTool("toolName", ctx)

  // Fetch the tool's input schema
  inputschema, err := tool.InputSchema()

  var paramsSchema openai.FunctionParameters
  _ = json.Unmarshal(inputschema, &paramsSchema)

  // Use this tool with OpenAI Go
  openAITool := openai.ChatCompletionToolParam{
    Function: openai.FunctionDefinitionParam{
      Name:        tool.Name(),
      Description: openai.String(tool.Description()),
      Parameters:  paramsSchema,
    },
  }

}

Configuration

The primary way to configure Toolbox is through the tools.yaml file. If you have multiple files, you can tell toolbox which to load with the --tools-file tools.yaml flag.

You can find more detailed reference documentation to all resource types in the Resources.

Sources

The sources section of your tools.yaml defines what data sources your Toolbox should have access to. Most tools will have at least one source to execute against.

sources:
  my-pg-source:
    kind: postgres
    host: 127.0.0.1
    port: 5432
    database: toolbox_db
    user: toolbox_user
    password: my-password

For more details on configuring different types of sources, see the Sources.

Tools

The tools section of a tools.yaml define the actions an agent can take: what kind of tool it is, which source(s) it affects, what parameters it uses, etc.

tools:
  search-hotels-by-name:
    kind: postgres-sql
    source: my-pg-source
    description: Search for hotels based on name.
    parameters:
      - name: name
        type: string
        description: The name of the hotel.
    statement: SELECT * FROM hotels WHERE name ILIKE '%' || $1 || '%';

For more details on configuring different types of tools, see the Tools.

Toolsets

The toolsets section of your tools.yaml allows you to define groups of tools that you want to be able to load together. This can be useful for defining different groups based on agent or application.

toolsets:
    my_first_toolset:
        - my_first_tool
        - my_second_tool
    my_second_toolset:
        - my_second_tool
        - my_third_tool

You can load toolsets by name:

# This will load all tools
all_tools = client.load_toolset()

# This will only load the tools listed in 'my_second_toolset'
my_second_toolset = client.load_toolset("my_second_toolset")

Versioning

This project uses semantic versioning (MAJOR.MINOR.PATCH). Since the project is in a pre-release stage (version 0.x.y), we follow the standard conventions for initial development:

Pre-1.0.0 Versioning

While the major version is 0, the public API should be considered unstable. The version will be incremented as follows:

0.MINOR.PATCH: The MINOR version is incremented when we add new functionality or make breaking, incompatible API changes.
0.MINOR.PATCH: The PATCH version is incremented for backward-compatible bug fixes.

Post-1.0.0 Versioning

Once the project reaches a stable 1.0.0 release, the versioning will follow the more common convention:

MAJOR.MINOR.PATCH: Incremented for incompatible API changes.
MAJOR.MINOR.PATCH: Incremented for new, backward-compatible functionality.
MAJOR.MINOR.PATCH: Incremented for backward-compatible bug fixes.

The public API that this applies to is the CLI associated with Toolbox, the interactions with official SDKs, and the definitions in the tools.yaml file.

Contributing

Contributions are welcome. Please, see the CONTRIBUTING to get started.

Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms. See Contributor Code of Conduct for more information.

Community

Join our discord community to connect with our developers!

bknd

Mon, 21 Jul 2025 15:39:18 +0800

bknd-io/bknd

⭐ Live Demo

bknd simplifies app development by providing a fully functional backend for database management, authentication, media and workflows. Being lightweight and built on Web Standards, it can be deployed nearly anywhere, including running inside your framework of choice. No more deploying multiple separate services!

Runtimes: Node.js 22+, Bun 1.0+, Deno, Browser, Cloudflare Workers/Pages, Vercel, Netlify, AWS Lambda, etc.
Databases:
- SQLite: LibSQL, Node SQLite, Bun SQLite, Cloudflare D1, Cloudflare Durable Objects SQLite, SQLocal
- Postgres: Vanilla Postgres, Supabase, Neon, Xata
Frameworks: React, Next.js, React Router, Astro, Vite, Waku
Storage: AWS S3, S3-compatible (Tigris, R2, Minio, etc.), Cloudflare R2 (binding), Cloudinary, Filesystem

For documentation and examples, please visit https://docs.bknd.io.

[!WARNING] This project requires Node.js 22 or higher (because of node:sqlite).

Please keep in mind that bknd is still under active development and therefore full backward compatibility is not guaranteed before reaching v1.0.0.

Size

The size on npm is misleading, as the bknd package includes the backend, the ui components as well as the whole backend bundled into the cli including static assets.

Depending on what you use, the size can be higher as additional dependencies are getting pulled in. The minimal size of a full bknd app as an API is around 300 kB gzipped (e.g. deployed as Cloudflare Worker).

Motivation

Creating digital products always requires developing both the backend (the logic) and the frontend (the appearance). Building a backend from scratch demands deep knowledge in areas such as authentication and database management. Using a backend framework can speed up initial development, but it still requires ongoing effort to work within its constraints (e.g., “how to do X with Y?”), which can quickly slow you down. Choosing a backend system is a tough decision, as you might not be aware of its limitations until you encounter them.

The solution: A backend system that only assumes and implements primitive details, integrates into multiple environments, and adheres to industry standards.

Features

⚡ Instant backend with full REST API:
- Data: Define, query, and control your data with ease.
- Auth: Easily implement reliable authentication strategies.
- Media: Effortlessly manage and serve all your media files.
- Flows: Design and run workflows with seamless automation. (UI integration coming soon!)
🌐 Built on Web Standards for maximum compatibility
🏃‍♂️ Multiple run modes
- standalone using the CLI
- using a JavaScript runtime (Node, Bun, workerd)
- using a React framework (Next.js, React Router, Astro)
📦 Official API and React SDK with type-safety
⚛️ React elements for auto-configured authentication and media components

Structure

The package is mainly split into 4 parts, each serving a specific purpose:

Import	Purpose
`bknd` `bknd/adapter/*`	Backend including APIs and adapters
`bknd/ui`	Admin UI components for react frameworks
`bknd/client`	TypeScript SDK and React hooks for the API endpoints
`bknd/elements`	React components for authentication and media

The backend (`bknd`)

Serve the backend as an API for any JS runtime or framework. The latter is especially handy, as it allows you to deploy your frontend and backend bundled together. Furthermore it allows adding additional logic in a way you’re already familar with. Just add another route and you’re good to go.

Here is an example of serving the API using node:

1
2

import { serve } from "bknd/adapter/node"
serve();

Integrated admin UI (`bknd/ui`)

The admin UI allows to manage your data including full configuration of your backend using a graphical user interface. Using vite, your admin route looks like this:

import { Admin } from "bknd/ui"
import "bknd/dist/styles.css";

export default function AdminPage() {
   return <Admin />
}

Using the REST API or TypeScript SDK (`bknd/client`)

If you’re not using a JavaScript environment, you can still access any endpoint using the REST API:

curl -XGET <your-endpoint>/api/data/entity/<entity>
{
  "data": [
    { "id": 1, ... },
    { "id": 2, ... }
  ],
  "meta": { /* ... */ }
}

In a JavaScript environment, you can use the TypeScript SDK with type-safety. The above example would look like this:

import { Api } from "bknd/client";

const api = new Api({ host: "<endpoint>" });
const { data } = await api.data.readMany("<entity>");

If you’re using React, there are 2 hooks exposed (useApi, useEntity), as well as an swr wrapper around each (useApiQuery, useEntityQuery). The swr wrapped hooks automatically handled query invalidation:

import { useState } from "react";
import { useEntityQuery } from "bknd/client";

export default function App() {
   const { data } = useEntityQuery("todos");   
   return <ul>
      {data?.map(todo => (
         <li key={todo.id}>{todo.name}</li>
      ))}
   </ul>
}

React elements (`bknd/elements`)

You don’t have to figure out API details to include media uploads to your app. For an user avatar upload, this is all you need:

import { Media } from "bknd/elements"
import "bknd/dist/main.css"

export function UserAvatar() {
   return <Media.Dropzone
     entity={{ name: "users", id: 1, field: "avatar" }}
     maxItems={1}
     overwrite
   />
}

The import path also exports components for login and registration forms which are automatically pointed to the bknd defaults.

🚀 Quick start

To quickly spin up an instance, run:

`1`	`npx bknd run`

Installation

`1`	`npm install bknd`

vanna

Fri, 18 Jul 2025 15:34:55 +0800

vanna-ai/vanna

GitHub	PyPI	Documentation	Gurubase

Vanna

Vanna is an MIT-licensed open-source Python RAG (Retrieval-Augmented Generation) framework for SQL generation and related functionality.

https://github.com/vanna-ai/vanna/assets/7146154/1901f47a-515d-4982-af50-f12761a3b2ce

How Vanna works

Vanna works in two easy steps - train a RAG “model” on your data, and then ask questions which will return SQL queries that can be set up to automatically run on your database.

Train a RAG “model” on your data.
Ask questions.

If you don’t know what RAG is, don’t worry – you don’t need to know how this works under the hood to use it. You just need to know that you “train” a model, which stores some metadata and then use it to “ask” questions.

See the base class for more details on how this works under the hood.

User Interfaces

These are some of the user interfaces that we’ve built using Vanna. You can use these as-is or as a starting point for your own custom interface.

Supported LLMs

Supported VectorStores

Supported Databases

Getting started

See the documentation for specifics on your desired database, LLM, etc.

If you want to get a feel for how it works after training, you can try this Colab notebook.

Install

`1`	`pip install vanna`

There are a number of optional packages that can be installed so see the documentation for more details.

Import

See the documentation if you’re customizing the LLM or vector database.

# The import statement will vary depending on your LLM and vector database. This is an example for OpenAI + ChromaDB

from vanna.openai.openai_chat import OpenAI_Chat
from vanna.chromadb.chromadb_vector import ChromaDB_VectorStore

class MyVanna(ChromaDB_VectorStore, OpenAI_Chat):
    def __init__(self, config=None):
        ChromaDB_VectorStore.__init__(self, config=config)
        OpenAI_Chat.__init__(self, config=config)

vn = MyVanna(config={'api_key': 'sk-...', 'model': 'gpt-4-...'})

# See the documentation for other options

Training

You may or may not need to run these vn.train commands depending on your use case. See the documentation for more details.

These statements are shown to give you a feel for how it works.

Train with DDL Statements

DDL statements contain information about the table names, columns, data types, and relationships in your database.

vn.train(ddl="""
    CREATE TABLE IF NOT EXISTS my-table (
        id INT PRIMARY KEY,
        name VARCHAR(100),
        age INT
    )
""")

Train with Documentation

Sometimes you may want to add documentation about your business terminology or definitions.

`1`	`vn.train(documentation="Our business defines XYZ as ...")`

Train with SQL

You can also add SQL queries to your training data. This is useful if you have some queries already laying around. You can just copy and paste those from your editor to begin generating new SQL.

`1`	`vn.train(sql="SELECT name, age FROM my-table WHERE name = 'John Doe'")`

Asking questions

`1`	`vn.ask("What are the top 10 customers by sales?")`

You’ll get SQL

SELECT c.c_name as customer_name,
        sum(l.l_extendedprice * (1 - l.l_discount)) as total_sales
FROM   snowflake_sample_data.tpch_sf1.lineitem l join snowflake_sample_data.tpch_sf1.orders o
        ON l.l_orderkey = o.o_orderkey join snowflake_sample_data.tpch_sf1.customer c
        ON o.o_custkey = c.c_custkey
GROUP BY customer_name
ORDER BY total_sales desc limit 10;

If you’ve connected to a database, you’ll get the table:

	CUSTOMER_NAME	TOTAL_SALES
0	Customer#000143500	6757566.0218
1	Customer#000095257	6294115.3340
2	Customer#000087115	6184649.5176
3	Customer#000131113	6080943.8305
4	Customer#000134380	6075141.9635
5	Customer#000103834	6059770.3232
6	Customer#000069682	6057779.0348
7	Customer#000102022	6039653.6335
8	Customer#000098587	6027021.5855
9	Customer#000064660	5905659.6159

You’ll also get an automated Plotly chart:

RAG vs. Fine-Tuning

RAG

Portable across LLMs
Easy to remove training data if any of it becomes obsolete
Much cheaper to run than fine-tuning
More future-proof – if a better LLM comes out, you can just swap it out

Fine-Tuning

Good if you need to minimize tokens in the prompt
Slow to get started
Expensive to train and run (generally)

Why Vanna?

High accuracy on complex datasets.
- Vanna’s capabilities are tied to the training data you give it
- More training data means better accuracy for large and complex datasets
Secure and private.
- Your database contents are never sent to the LLM or the vector database
- SQL execution happens in your local environment
Self learning.
- If using via Jupyter, you can choose to “auto-train” it on the queries that were successfully executed
- If using via other interfaces, you can have the interface prompt the user to provide feedback on the results
- Correct question to SQL pairs are stored for future reference and make the future results more accurate
Supports any SQL database.
- The package allows you to connect to any SQL database that you can otherwise connect to with Python
Choose your front end.
- Most people start in a Jupyter Notebook.
- Expose to your end users via Slackbot, web app, Streamlit app, or a custom front end.

Extending Vanna

Vanna is designed to connect to any database, LLM, and vector database. There’s a VannaBase abstract base class that defines some basic functionality. The package provides implementations for use with OpenAI and ChromaDB. You can easily extend Vanna to use your own LLM or vector database. See the documentation for more details.

Vanna in 100 Seconds

https://github.com/vanna-ai/vanna/assets/7146154/eb90ee1e-aa05-4740-891a-4fc10e611cab

More resources

drawdb

Sat, 05 Jul 2025 15:28:25 +0800

drawdb-io/drawdb

^{Special thanks to:}

Next-gen AI-powered intelligent terminal for all platforms

drawDB

Free, simple, and intuitive database schema editor and SQL generator.

DrawDB is a robust and user-friendly database entity relationship (DBER) editor right in your browser. Build diagrams with a few clicks, export sql scripts, customize your editor, and more without creating an account. See the full set of features here.

Getting Started

Local Development

git clone https://github.com/drawdb-io/drawdb
cd drawdb
npm install
npm run dev

Build

git clone https://github.com/drawdb-io/drawdb
cd drawdb
npm install
npm run build

Docker Build

1
2

docker build -t drawdb .
docker run -p 3000:80 drawdb

If you wish to work with sharing, set up server and environment variables according to .env.sample. This is not required unless you want to share files.

telegram-search

Wed, 28 May 2025 15:29:34 +0800

groupultra/telegram-search

Telegram Search

English | 快速开始

一个功能强大的 Telegram 聊天记录搜索工具，支持向量搜索和语义匹配。基于 OpenAI 的语义向量技术，让你的 Telegram 消息检索更智能、更精准。

欢迎 PR 贡献！
由于项目处于快速迭代阶段，可能会出现数据库不兼容的情况，建议定期备份数据。

💖 赞助者

🚀 快速开始

安装步骤

克隆仓库：

1
2

git clone https://github.com/GramSearch/telegram-search.git
cd telegram-search

安装依赖：

`1`	`pnpm install`

配置环境：

`1`	`cp config/config.example.yaml config/config.yaml`

启动数据库容器：

`1`	`docker compose up -d`

同步数据库表结构：

`1`	`pnpm run db:migrate`

启动服务：

# 启动后端服务
pnpm run dev:server

# 启动前端界面
pnpm run dev:frontend

访问 http://localhost:3333 即可打开搜索界面。

🚀 Activity

📝 License

appwrite

Fri, 23 May 2025 15:28:13 +0800

appwrite/appwrite

Get started with Appwrite Join the Init kick off event 19th of May: The future of Appwrite with Founder & CEO Eldad Fux

Appwrite is a backend platform for developing Web, Mobile, and Flutter applications. Built with the open source community and optimized for developer experience in the coding languages you love.

English | 简体中文

Appwrite is an end-to-end backend server for Web, Mobile, Native, or Backend apps packaged as a set of Docker microservices. Appwrite abstracts the complexity and repetitiveness required to build a modern backend API from scratch and allows you to build secure apps faster.

Using Appwrite, you can easily integrate your app with user authentication and multiple sign-in methods, a database for storing and querying users and team data, storage and file management, image manipulation, Cloud Functions, messaging, and more services.

Find out more at: https://appwrite.io.

Table of Contents:

Getting Started
Self-Hosting
One-Click Setups
Getting Started
- Products
- SDKs
  - Client
  - Server
  - Community
Architecture
Contributing
Security
Follow Us
License

Getting Started

The easiest way to get started with Appwrite is by signing up for Appwrite Cloud. While Appwrite Cloud is in public beta, you can build with Appwrite completely free, and we won’t collect you credit card information.

Self-Hosting

Appwrite is designed to run in a containerized environment. Running your server is as easy as running one command from your terminal. You can either run Appwrite on your localhost using docker-compose or on any other container orchestration tool, such as Kubernetes, Docker Swarm, or Rancher.

Before running the installation command, make sure you have Docker installed on your machine:

Unix

docker run -it --rm \
    --volume /var/run/docker.sock:/var/run/docker.sock \
    --volume "$(pwd)"/appwrite:/usr/src/code/appwrite:rw \
    --entrypoint="install" \
    appwrite/appwrite:1.7.2

Windows

CMD

docker run -it --rm ^
    --volume //var/run/docker.sock:/var/run/docker.sock ^
    --volume "%cd%"/appwrite:/usr/src/code/appwrite:rw ^
    --entrypoint="install" ^
    appwrite/appwrite:1.7.2

PowerShell

docker run -it --rm `
    --volume /var/run/docker.sock:/var/run/docker.sock `
    --volume ${pwd}/appwrite:/usr/src/code/appwrite:rw `
    --entrypoint="install" `
    appwrite/appwrite:1.7.2

Once the Docker installation is complete, go to http://localhost to access the Appwrite console from your browser. Please note that on non-Linux native hosts, the server might take a few minutes to start after completing the installation.

For advanced production and custom installation, check out our Docker environment variables docs. You can also use our public docker-compose.yml and .env files to manually set up an environment.

Upgrade from an Older Version

If you are upgrading your Appwrite server from an older version, you should use the Appwrite migration tool once your setup is completed. For more information regarding this, check out the Installation Docs.

One-Click Setups

In addition to running Appwrite locally, you can also launch Appwrite using a pre-configured setup. This allows you to get up and running quickly with Appwrite without installing Docker on your local machine.

Choose from one of the providers below:

_DigitalOcean

_Gitpod

_{Akamai Compute}

_{AWS Marketplace}

Getting Started

Getting started with Appwrite is as easy as creating a new project, choosing your platform, and integrating its SDK into your code. You can easily get started with your platform of choice by reading one of our Getting Started tutorials.

Platform	Technology
Web app	Quick start for Web
	Quick start for Next.js
	Quick start for React
	Quick start for Vue.js
	Quick start for Nuxt
	Quick start for SvelteKit
	Quick start for Refine
	Quick start for Angular
Mobile and Native	Quick start for React Native
	Quick start for Flutter
	Quick start for Apple
	Quick start for Android
Server	Quick start for Node.js
	Quick start for Python
	Quick start for .NET
	Quick start for Dart
	Quick start for Ruby
	Quick start for Deno
	Quick start for PHP
	Quick start for Kotlin
	Quick start for Swift

Products

Account - Manage current user authentication and account. Track and manage the user sessions, devices, sign-in methods, and security logs.
Users - Manage and list all project users when building backend integrations with Server SDKs.
Teams - Manage and group users in teams. Manage memberships, invites, and user roles within a team.
Databases - Manage databases, collections, and documents. Read, create, update, and delete documents and filter lists of document collections using advanced filters.
Storage - Manage storage files. Read, create, delete, and preview files. Manipulate the preview of your files to perfectly fit your app. All files are scanned by ClamAV and stored in a secure and encrypted way.
Functions - Customize your Appwrite project by executing your custom code in a secure, isolated environment. You can trigger your code on any Appwrite system event either manually or using a CRON schedule.
Messaging - Communicate with your users through push notifications, emails, and SMS text messages using Appwrite Messaging.
Realtime - Listen to real-time events for any of your Appwrite services including users, storage, functions, databases, and more.
Locale - Track your user’s location and manage your app locale-based data.
Avatars - Manage your users’ avatars, countries’ flags, browser icons, and credit card symbols. Generate QR codes from links or plaintext strings.

For the complete API documentation, visit https://appwrite.io/docs. For more tutorials, news and announcements check out our blog and Discord Server.

SDKs

Below is a list of currently supported platforms and languages. If you would like to help us add support to your platform of choice, you can go over to our SDK Generator project and view our contribution guide.

Client

:white_check_mark: Web (Maintained by the Appwrite Team)
:white_check_mark: Flutter (Maintained by the Appwrite Team)
:white_check_mark: Apple (Maintained by the Appwrite Team)
:white_check_mark: Android (Maintained by the Appwrite Team)
:white_check_mark: React Native - Beta (Maintained by the Appwrite Team)

Server

:white_check_mark: NodeJS (Maintained by the Appwrite Team)
:white_check_mark: PHP (Maintained by the Appwrite Team)
:white_check_mark: Dart (Maintained by the Appwrite Team)
:white_check_mark: Deno (Maintained by the Appwrite Team)
:white_check_mark: Ruby (Maintained by the Appwrite Team)
:white_check_mark: Python (Maintained by the Appwrite Team)
:white_check_mark: Kotlin (Maintained by the Appwrite Team)
:white_check_mark: Swift (Maintained by the Appwrite Team)
:white_check_mark: .NET - Beta (Maintained by the Appwrite Team)

Community

:white_check_mark: Appcelerator Titanium (Maintained by Michael Gangolf)
:white_check_mark: Godot Engine (Maintained by fenix-hub @GodotNuts)

Looking for more SDKs? - Help us by contributing a pull request to our SDK Generator!

Architecture

Appwrite uses a microservices architecture that was designed for easy scaling and delegation of responsibilities. In addition, Appwrite supports multiple APIs, such as REST, WebSocket, and GraphQL to allow you to interact with your resources by leveraging your existing knowledge and protocols of choice.

The Appwrite API layer was designed to be extremely fast by leveraging in-memory caching and delegating any heavy-lifting tasks to the Appwrite background workers. The background workers also allow you to precisely control your compute capacity and costs using a message queue to handle the load. You can learn more about our architecture in the contribution guide.

Contributing

All code contributions, including those of people having commit access, must go through a pull request and be approved by a core developer before being merged. This is to ensure a proper review of all the code.

We truly :heart: pull requests! If you wish to help, you can learn more about how you can contribute to this project in the contribution guide.

Security

For security issues, kindly email us at security@appwrite.io instead of posting a public issue on GitHub.

Join our growing community around the world! Check out our official Blog. Follow us on X, LinkedIn, Dev Community or join our live Discord server for more help, ideas, and discussions.

License

This repository is available under the BSD 3-Clause License.

limbo

Mon, 19 May 2025 15:30:44 +0800

tursodatabase/limbo

Project Limbo

Limbo is a project to build the modern evolution of SQLite.

Features and Roadmap

Limbo is a work-in-progress, in-process OLTP database engine library written in Rust that has:

Asynchronous I/O support on Linux with io_uring
SQLite compatibility [doc] for SQL dialect, file formats, and the C API
Language bindings for JavaScript/WebAssembly, Rust, Go, Python, and Java
OS support for Linux, macOS, and Windows

In the future, we will be also working on:

Integrated vector search for embeddings and vector similarity.
BEGIN CONCURRENT for improved write throughput.
Improved schema management including better ALTER support and strict column types by default.

Getting Started

💻 Command Line

You can install the latest `limbo` release with:

1
2

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

Then launch the shell to execute SQL statements:

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

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

`1`	`cargo run`

🦀 Rust

`1`	`cargo add limbo`

Example usage:

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

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

✨ JavaScript

`1`	`npm i limbo-wasm`

Example usage:

import { Database } from 'limbo-wasm';

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

🐍 Python

`1`	`pip install pylimbo`

Example usage:

import limbo

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

🐹 Go

Clone the repository
Build the library and set your LD_LIBRARY_PATH to include limbo’s target directory

1
2

cargo build --package limbo-go
export LD_LIBRARY_PATH=/path/to/limbo/target/debug:$LD_LIBRARY_PATH

Use the driver

1
2

go get github.com/tursodatabase/limbo
go install github.com/tursodatabase/limbo

Example usage:

import (
    "database/sql"
    _"github.com/tursodatabase/limbo"
)

conn, _ = sql.Open("sqlite3", "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)
}

☕️ Java

We integrated Limbo into JDBC. For detailed instructions on how to use Limbo with java, please refer to the README.md under bindings/java.

Contributing

We’d love to have you contribute to Limbo! Please check out the contribution guide to get started.

FAQ

How is Limbo different from Turso’s libSQL?

Limbo is a project to build the modern evolution of SQLite in Rust, with a strong open contribution focus and features like native async support, vector search, and more. The libSQL project is also an attempt to evolve SQLite in a similar direction, but through a fork rather than a rewrite.

Rewriting SQLite in Rust started as an unassuming experiment, and due to its incredible success, replaces libSQL as our intended direction. At this point, libSQL is production ready, Limbo is not - although it is evolving rapidly. As the project starts to near production readiness, we plan to rename it to just “Turso”. More details here.

Publications

Pekka Enberg, Sasu Tarkoma, Jon Crowcroft Ashwin Rao (2024). Serverless Runtime / Database Co-Design With Asynchronous I/O. In EdgeSys ‘24. [PDF]
Pekka Enberg, Sasu Tarkoma, and Ashwin Rao (2023). Towards Database and Serverless Runtime Co-Design. In CoNEXT-SW ’23. [PDF] [Slides]

License

This project is licensed under the MIT license.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Limbo by you, shall be licensed as MIT, without any additional terms or conditions.

Contributors

Thanks to all the contributors to Limbo!

PyWxDump

Sat, 17 May 2025 15:27:26 +0800

xaoyaoo/PyWxDump

PyWxDump

Welcome to provide more ideas or code to improve this project together.

If you are a novice, please pay attention to the Official Accounts: `逍遥之芯` (the QR code is below), and reply: `PyWxDump` to get a picture text tutorial.

If you have any questions, please check first: FAQ Whether there is an answer, or follow the Official Accounts to reply: `FAQ`.

QQ GROUP：276392799 or 276392799（PASSWORD,please read:UserGuide.md）.

I. Project Introduction

1. Brief Introduction

PyWxDump is a tool for obtaining wx account information (nicknames/accounts/phones/emails/database keys), decrypting databases, viewing wx chat, and exporting chat as html backups.

Super eager for stars, if you’ve come across this project, please give me a ! Thank you so much~

2. Feature

2.1 Core

(1) Get the base address offset of WeChat nickname, WeChat account, WeChat phone number, WeChat email, and WeChat KEY
(2) Get the WeChat nickname, WeChat account, WeChat phone number, WeChat email, WeChat KEY, WeChat original ID (wxid_******), and WeChat folder path of the currently logged-in WeChat
(3) Decrypt WeChat database based on key
(4) Combine multiple types of databases for unified viewing

2.2 Extend Function

(1) View chat history through the web
(2) Support exporting chat logs as html, csv, and backing up WeChat chat logs
(3) Remote viewing of WeChat chat history (must be network accessible, such as a local area network)

2.3 Document Class

(1) Provide descriptions of some fields in the database
(2) Provide CE to obtain the base address offset method
(3) Provide a decryption method for MAC database

2.4 Other functions

(1) Added a minimalist version of pywxdumpmini, which provides only the ability to obtain database keys and database locations
(2) Support multiple WeChat opening scenarios, obtain multiple user information, etc.

Utilize the scene

Network security…
Daily backup archiving
View chat history remotely (view chat history through the web)
Wait……………

3. Update plan

1.Analyze chat logs of each person and generate word clouds.
~~2.Analyze the number of chats per person per day and generate a line chart (day-number of chats)~~
~~3.Analyze the monthly and annual chat volume of different people and generate a line chart~~
~~4.Generate annual visualization reports~~
8.Increase support for enterprise WeChat
12.Viewing and backing up of the circle of friends
13.Clean up WeChat storage space and reduce the space occupied by WeChat (hopefully by selecting a person or group and finding out the media files involved in the chat logs of this group, such as pictures, videos, files, voice recordings, etc., and selectively (such as time periods) or batch-wise clearing them from the computer’s cache by group conversation.)
14.Automatically send messages to specified people through UI control

4. Other

PyWxDump is a refactored python language version of SharpWxDump, with many new features added.

Project address: https://github.com/xaoyaoo/PyWxDump
Currently tested only under Windows, there may be issues under mac and Linux.
If you find any missing or incorrect information, bugs, or suggestions for improvement in the WX_OFFS.json, please submit an issue on GitHub.
For common issues, please refer to FAQ, and for the update log, please refer to CHANGELOG
Web UI repository location wxdump_web
If you are interested in the implementation principle of wxdump, please pay attention to the Official Accounts: 逍遥之芯, reply: 原理 to get the principle analysis.
:sparkling_heart: Support Me

5. Star History

click to expand

Ⅱ. Instructions For Use

Detailed instructions, see: UserGuide.md
the minimalist version, see: pywxdumpmini
If you want to modify the UI, clone the wx_dump_web and modify it as needed (the UI is developed using VUE+ElementUI)

【note】:

For obtaining the base address using cheat engine, refer to CE obtaining base address.md (This method can be replaced by the wxdump bias command, and is only used for learning principles.)
For database parsing, refer to wx database brief.md

Ⅲ. Disclaimer (VERY VERY VERY IMPORTANT ! ! ! ! ! !)

1. Purpose of use

This project is only for learning and communication purposes, please do not use it for illegal purposes, please do not use it for illegal purposes, please do not use it for illegal purposes, otherwise the consequences will be borne by yourself.
Users understand and agree that any violation of laws and regulations, infringement of the legitimate rights and interests of others, is unrelated to this project and its developers, and the consequences are borne by the user themselves.

2. Usage Period

You should delete the source code and (compiled) program of this project within 24 hours of downloading, saving, compiling, and using it; any use beyond this period is not related to this project or its developer.

3. Operation specifications

This project only allows backup and viewing of the database under authorization. It is strictly prohibited for illegal purposes, otherwise all related responsibilities will be borne by the user. Any legal liability incurred by the user due to violation of this regulation will be borne by the user, and is unrelated to this project and its developer.
It is strictly prohibited to use it to steal others’ privacy. Otherwise, all relevant responsibilities shall be borne by yourself.
It is strictly prohibited to conduct secondary development, otherwise all related responsibilities shall be borne by yourself.

4. Acceptance of Disclaimer

Downloading, saving, further browsing the source code, or downloading, installing, compiling, and using this program indicates that you agree with this warning and promise to abide by it;

5. Forbidden for illegal testing or penetration

It is prohibited to use the relevant technologies of this project to engage in illegal testing or penetration, and it is prohibited to use the relevant codes or related technologies of this project to engage in any illegal work. Any adverse consequences arising therefrom are not related to this project and its developers.
Any resulting adverse consequences, including but not limited to data leakage, system failure, and privacy infringement, are not related to this project or its developers and are the responsibility of the user.

6. Modification of disclaimer

This disclaimer may be modified and adjusted based on the project’s operating conditions and changes in laws and regulations. Users should regularly check this page for the latest version of the disclaimer, and should comply with the latest version of the disclaimer when using this project.

7. Others

In addition to the provisions of this disclaimer, users should comply with relevant laws, regulations, and ethical norms during the use of this project. The project and its developers will not be held responsible for any disputes or losses caused by users’ violation of relevant regulations.
Users are requested to carefully read and understand all contents of this disclaimer, and ensure that they strictly comply with relevant regulations when using this project.

Ⅳ. Acknowledgments

UI CONTRIBUTORS:

otherContributors:

643104191 (add ctypes_utils, Accelerated the acquisition of wxinfo; 9e3e4cb)

Python-100-Days

Sun, 04 May 2025 15:26:27 +0800

jackfrued/Python-100-Days

Python - 100天从新手到大师

作者：骆昊

说明：如果访问 GitHub 比较慢的话，可以关注我的知乎号（Python-Jack），上面的“从零开始学Python”专栏（对应本项目前 20 天的内容）比较适合初学者，其他的专栏如“数据思维和统计思维”、“基于Python的数据分析”、“说走就走的AI之旅”等也在持续创作和更新中，欢迎大家关注、点赞和评论。如果希望免费学习打卡或者参与问题讨论，可以加入下面的 QQ 交流群（三个群加一个即可），请不要重复加群，也不要在群里发布广告和其他色情、低俗或敏感内容。如果有付费学习或付费咨询的需求，可以添加我的私人微信（微信号：jackfrued），备注好自己的称呼和需求，我会为大家提供力所能及的帮助。

本项目对应的部分视频已经同步到 Bilibili，有兴趣的小伙伴可以点赞、投币、关注，一键三连支持一下！

Python应用领域和职业发展分析

简单的说，Python是一个“优雅”、“明确”、“简单”的编程语言。

学习曲线低，非专业人士也能上手
开源系统，拥有强大的生态圈
解释型语言，完美的平台可移植性
动态类型语言，支持面向对象和函数式编程
代码规范程度高，可读性强

Python在以下领域都有用武之地。

后端开发 - Python / Java / Go / PHP
DevOps - Python / Shell / Ruby
数据采集 - Python / C++ / Java
量化交易 - Python / C++ / R
数据科学 - Python / R / Julia / Matlab
机器学习 - Python / R / C++ / Julia
自动化测试 - Python / Shell

作为一名Python开发者，根据个人的喜好和职业规划，可以选择的就业领域也非常多。

Python后端开发工程师（服务器、云平台、数据接口）
Python运维工程师（自动化运维、SRE、DevOps）
Python数据分析师（数据分析、商业智能、数字化运营）
Python数据科学家（机器学习、深度学习、算法专家）
Python爬虫工程师（不推荐此赛道！！！）
Python测试工程师（自动化测试、测试开发）

说明：目前，数据科学赛道是非常热门的方向，因为不管是互联网行业还是传统行业都已经积累了大量的数据，各行各业都需要数据科学家从已有的数据中发现更多的商业价值，从而为企业的决策提供数据的支撑，这就是所谓的数据驱动决策。

给初学者的几个建议：

Make English as your working language. （让英语成为你的工作语言）
Practice makes perfect. （熟能生巧）
All experience comes from the mistakes you’ve made. （所有的经验都源于你犯过的错误）
Don’t be a freeloader. （不要当伸手党）
Either outstanding or out. （要么出众，要么出局）

Day01~20 - Python语言基础

Day01 - 初识Python

Python简介
- Python编年史
- Python优缺点
- Python应用领域
安装Python环境
- Windows环境
- macOS环境

Day02 - 第一个Python程序

编写代码的工具
你好世界
注释你的代码

Day03 - Python语言中的变量

一些常识
变量和类型
变量命名
变量的使用

Day04 - Python语言中的运算符

算术运算符
赋值运算符
比较运算符和逻辑运算符
运算符和表达式应用
- 华氏和摄氏温度转换
- 计算圆的周长和面积
- 判断闰年

Day05 - 分支结构

使用if和else构造分支结构
使用match和case构造分支结构
分支结构的应用
- 分段函数求值
- 百分制成绩转换成等级
- 计算三角形的周长和面积

Day06 - 循环结构

for-in循环
while循环
break和continue
嵌套的循环结构
循环结构的应用
- 判断素数
- 最大公约数
- 猜数字游戏

Day07 - 分支和循环结构实战

例子1：100以内的素数
例子2：斐波那契数列
例子3：寻找水仙花数
例子4：百钱百鸡问题
例子5：CRAPS赌博游戏

Day08 - 常用数据结构之列表-1

创建列表
列表的运算
元素的遍历

Day09 - 常用数据结构之列表-2

列表的方法
- 添加和删除元素
- 元素位置和频次
- 元素排序和反转
列表生成式
嵌套列表
列表的应用

Day10 - 常用数据结构之元组

元组的定义和运算
打包和解包操作
交换变量的值
元组和列表的比较

Day11 - 常用数据结构之字符串

字符串的定义
- 转义字符
- 原始字符串
- 字符的特殊表示
字符串的运算
- 拼接和重复
- 比较运算
- 成员运算
- 获取字符串长度
- 索引和切片
字符的遍历
字符串的方法
- 大小写相关操作
- 查找操作
- 性质判断
- 格式化
- 修剪操作
- 替换操作
- 拆分与合并
- 编码与解码
- 其他方法

Day12 - 常用数据结构之集合

创建集合
元素的变量
集合的运算
- 成员运算
- 二元运算
- 比较运算
集合的方法
不可变集合

Day13 - 常用数据结构之字典

创建和使用字典
字典的运算
字典的方法
字典的应用

Day14 - 函数和模块

定义函数
函数的参数
- 位置参数和关键字参数
- 参数的默认值
- 可变参数
用模块管理函数
标准库中的模块和函数

Day15 - 函数应用实战

例子1：随机验证码
例子2：判断素数
例子3：最大公约数和最小公倍数
例子4：数据统计
例子5：双色球随机选号

Day16 - 函数使用进阶

高阶函数
Lambda函数
偏函数

Day17 - 函数高级应用

装饰器
递归调用

Day18 - 面向对象编程入门

类和对象
定义类
创建和使用对象
初始化方法
面向对象的支柱
面向对象案例
- 例子1：数字时钟
- 例子2：平面上的点

Day19 - 面向对象编程进阶

可见性和属性装饰器
动态属性
静态方法和类方法
继承和多态

Day20 - 面向对象编程应用

扑克游戏
工资结算系统

Day21~30 - Python语言应用

Day21 - 文件读写和异常处理

打开和关闭文件
读写文本文件
异常处理机制
上下文管理器语法
读写二进制文件

Day22 - 对象的序列化和反序列化

JSON概述
读写JSON格式的数据
包管理工具pip
使用网络API获取数据

Day23 - Python读写CSV文件

CSV文件介绍
将数据写入CSV文件
从CSV文件读取数据

Day24 - Python读写Excel文件-1

Excel简介
读Excel文件
写Excel文件
调整样式
公式计算

Day25 - Python读写Excel文件-2

Excel简介
读Excel文件
写Excel文件
调整样式
生成统计图表

Day26 - Python操作Word和PowerPoint文件

操作Word文档
生成PowerPoint

Day27 - Python操作PDF文件

从PDF中提取文本
旋转和叠加页面
加密PDF文件
批量添加水印
创建PDF文件

Day28 - Python处理图像

入门知识
用Pillow处理图像
使用Pillow绘图

Day29 - Python发送邮件和短信

发送电子邮件
发送短信

Day30 - 正则表达式的应用

正则表达式相关知识
Python对正则表达式的支持
- 例子1：输入验证
- 例子2：内容提取
- 例子3：内容替换
- 例子4：长句拆分

Day31~35 - 其他相关内容

Python语言进阶

重要知识点
数据结构和算法
函数的使用方式
面向对象相关知识
迭代器和生成器
并发编程

Web前端入门

用HTML标签承载页面内容
用CSS渲染页面
用JavaScript处理交互式行为
Vue.js入门
Element的使用
Bootstrap的使用

玩转Linux操作系统

操作系统发展史和Linux概述
Linux基础命令
Linux中的实用程序
Linux的文件系统
Vim编辑器的应用
环境变量和Shell编程
软件的安装和服务的配置
网络访问和管理
其他相关内容

Day36~45 - 数据库基础和进阶

Day36 - 关系型数据库和MySQL概述

关系型数据库概述
MySQL简介
安装MySQL
MySQL基本命令

Day37 - SQL详解之DDL

建库建表
删除表和修改表

Day38 - SQL详解之DML

insert操作
delete操作
update操作

Day39 - SQL详解之DQL

投影和别名
筛选数据
空值处理
去重
排序
聚合函数
嵌套查询
分组操作
表连接
- 笛卡尔积
- 内连接
- 自然连接
- 外连接
窗口函数
- 定义窗口
- 排名函数
- 取数函数

Day40 - SQL详解之DCL

创建用户
授予权限
召回权限

Day41 - MySQL新特性

JSON类型
窗口函数
公共表表达式

Day42 - 视图、函数和过程

视图
- 使用场景
- 创建视图
- 使用限制
函数
- 内置函数
- 用户自定义函数（UDF）
过程
- 创建过程
- 调用过程

Day43 - 索引

执行计划
索引的原理
创建索引
- 普通索引
- 唯一索引
- 前缀索引
- 复合索引
注意事项

Day44 - Python接入MySQL数据库

安装三方库
创建连接
获取游标
执行SQL语句
通过游标抓取数据
事务提交和回滚
释放连接
编写ETL脚本

Day45 - 大数据平台和HiveSQL

Hadoop生态圈
Hive概述
准备工作
数据类型
DDL操作
DML操作
数据查询

Day46~60 - 实战Django

Day46 - Django快速上手

Web应用工作机制
HTTP请求和响应
Django框架概述
5分钟快速上手

Day47 - 深入模型

关系型数据库配置
使用ORM完成对模型的CRUD操作
管理后台的使用
Django模型最佳实践
模型定义参考

Day48 - 静态资源和Ajax请求

加载静态资源
Ajax概述
用Ajax实现投票功能

Day49 - Cookie和Session

实现用户跟踪
cookie和session的关系
Django框架对session的支持
视图函数中的cookie读写操作

Day50 - 报表和日志

通过HttpResponse修改响应头
使用StreamingHttpResponse处理大文件
使用xlwt生成Excel报表
使用reportlab生成PDF报表
使用ECharts生成前端图表

Day51 - 日志和调试工具栏

配置日志
配置Django-Debug-Toolbar
优化ORM代码

Day52 - 中间件的应用

什么是中间件
Django框架内置的中间件
自定义中间件及其应用场景

Day53 - 前后端分离开发入门

返回JSON格式的数据
用Vue.js渲染页面

Day54 - RESTful架构和DRF入门

REST概述
DRF库使用入门
前后端分离开发
JWT的应用

Day55 - RESTful架构和DRF进阶

使用CBV
数据分页
数据筛选

Day56 - 使用缓存

网站优化第一定律
在Django项目中使用Redis提供缓存服务
在视图函数中读写缓存
使用装饰器实现页面缓存
为数据接口提供缓存服务

Day57 - 接入三方平台

文件上传表单控件和图片文件预览
服务器端如何处理上传的文件

Day58 - 异步任务和定时任务

网站优化第二定律
配置消息队列服务
在项目中使用Celery实现任务异步化
在项目中使用Celery实现定时任务

Day59 - 单元测试

Day60 - 项目上线

Python中的单元测试
Django框架对单元测试的支持
使用版本控制系统
配置和使用uWSGI
动静分离和Nginx配置
配置HTTPS
配置域名解析

Day61~65 - 网络数据采集

Day61 - 网络数据采集概述

网络爬虫的概念及其应用领域
网络爬虫的合法性探讨
开发网络爬虫的相关工具
一个爬虫程序的构成

Day62 - 数据抓取和解析

使用requests三方库实现数据抓取
页面解析的三种方式
- 正则表达式解析
- XPath解析
- CSS选择器解析

Day63 - Python中的并发编程

Day64 - 使用Selenium抓取网页动态内容

安装Selenium
加载页面
查找元素和模拟用户行为
隐式等待和显示等待
执行JavaScript代码
Selenium反爬破解
设置无头浏览器

Day65 - 爬虫框架Scrapy简介

Scrapy核心组件
Scrapy工作流程
安装Scrapy和创建项目
编写蜘蛛程序
编写中间件和管道程序
Scrapy配置文件

Day66~80 - Python数据分析

Day66 - 数据分析概述

数据分析师的职责
数据分析师的技能栈
数据分析相关库

Day67 - 环境准备

安装和使用anaconda
- conda相关命令
安装和使用jupyter-lab
- 安装和启动
- 使用小技巧

Day68 - NumPy的应用-1

创建数组对象
数组对象的属性
数组对象的索引运算
- 普通索引
- 花式索引
- 布尔索引
- 切片索引
案例：使用数组处理图像

Day69 - NumPy的应用-2

数组对象的相关方法
- 获取描述性统计信息
- 其他相关方法

Day70 - NumPy的应用-3

数组的运算
- 数组跟标量的运算
- 数组跟数组的运算
通用一元函数
通用二元函数
广播机制
Numpy常用函数

Day71 - NumPy的应用-4

向量
行列式
矩阵
多项式

Day72 - 深入浅出pandas-1

创建Series对象
Series对象的运算
Series对象的属性和方法

Day73 - 深入浅出pandas-2

创建DataFrame对象
DataFrame对象的属性和方法
读写DataFrame中的数据

Day74 - 深入浅出pandas-3

数据重塑
- 数据拼接
- 数据合并
数据清洗
- 缺失值
- 重复值
- 异常值
- 预处理

Day75 - 深入浅出pandas-4

数据透视
- 获取描述性统计信息
- 排序和头部值
- 分组聚合
- 透视表和交叉表
数据呈现

Day76 - 深入浅出pandas-5

计算同比环比
窗口计算
相关性判定

Day77 - 深入浅出pandas-6

索引的使用
- 范围索引
- 分类索引
- 多级索引
- 间隔索引
- 日期时间索引

Day78 - 数据可视化-1

安装和导入matplotlib
创建画布
创建坐标系
绘制图表
- 折线图
- 散点图
- 柱状图
- 饼状图
- 直方图
- 箱线图
显示和保存图表

Day79 - 数据可视化-2

高阶图表
- 气泡图
- 面积图
- 雷达图
- 玫瑰图
- 3D图表

Day80 - 数据可视化-3

Seaborn
Pyecharts

Day81~90 - 机器学习

Day81 - 浅谈机器学习

人工智能发展史
什么是机器学习
机器学习应用领域
机器学习的分类
机器学习的步骤
第一次机器学习

Day82 - k最近邻算法

距离的度量
数据集介绍
kNN分类的实现
模型评估
参数调优
kNN回归的实现

Day83 - 决策树和随机森林

决策树的构建
- 特征选择
- 数据分裂
- 树的剪枝
实现决策树模型
随机森林概述

Day84 - 朴素贝叶斯算法

贝叶斯定理
朴素贝叶斯
算法原理
- 训练阶段
- 预测阶段
- 代码实现
算法优缺点

Day85 - 回归模型

回归模型的分类
回归系数的计算
新数据集介绍
线性回归代码实现
回归模型的评估
引入正则化项
线性回归另一种实现
多项式回归
逻辑回归

Day86 - K-Means聚类算法

算法原理
数学描述
代码实现

Day87 - 集成学习算法

算法分类
AdaBoost
GBDT
XGBoost
LightGBM

Day88 - 神经网络模型

基本构成
工作原理
代码实现
模型优缺点

Day89 - 自然语言处理入门

词袋模型
词向量
NPLM和RNN
Seq2Seq
Transformer

Day90 - 机器学习实战

数据探索
特征工程
模型训练
模型评估
模型部署

Day91~99 - 团队项目开发

第91天：团队项目开发的问题和解决方案

软件过程模型
- 经典过程模型（瀑布模型）
  - 可行性分析（研究做还是不做），输出《可行性分析报告》。
  - 需求分析（研究做什么），输出《需求规格说明书》和产品界面原型图。
  - 概要设计和详细设计，输出概念模型图（ER图）、物理模型图、类图、时序图等。
  - 编码 / 测试。
  - 上线 / 维护。
  瀑布模型最大的缺点是无法拥抱需求变化，整套流程结束后才能看到产品，团队士气低落。
- 敏捷开发（Scrum）- 产品所有者、Scrum Master、研发人员 - Sprint
  - 产品的Backlog（用户故事、产品原型）。
  - 计划会议（评估和预算）。
  - 日常开发（站立会议、番茄工作法、结对编程、测试先行、代码重构……）。
  - 修复bug（问题描述、重现步骤、测试人员、被指派人）。
  - 发布版本。
  - 评审会议（Showcase，用户需要参与）。
  - 回顾会议（对当前迭代周期做一个总结）。
  补充：敏捷软件开发宣言
  - 个体和互动 高于流程和工具
  - 工作的软件 高于详尽的文档
  - 客户合作 高于合同谈判
  - 响应变化 高于遵循计划
  角色：产品所有者（决定做什么，能对需求拍板的人）、团队负责人（解决各种问题，专注如何更好的工作，屏蔽外部对开发团队的影响）、开发团队（项目执行人员，具体指开发人员和测试人员）。
  
  准备工作：商业案例和资金、合同、憧憬、初始产品需求、初始发布计划、入股、组建团队。
  
  敏捷团队通常人数为8-10人。
  
  工作量估算：将开发任务量化，包括原型、Logo设计、UI设计、前端开发等，尽量把每个工作分解到最小任务量，最小任务量标准为工作时间不能超过两天，然后估算总体项目时间。把每个任务都贴在看板上面，看板上分三部分：to do（待完成）、in progress（进行中）和done（已完成）。
项目团队组建
- 团队的构成和角色
- 编程规范和代码审查（flake8、pylint）
- Python中的一些“惯例”（请参考《Python惯例-如何编写Pythonic的代码》）
- 影响代码可读性的原因：
  - 代码注释太少或者没有注释
  - 代码破坏了语言的最佳实践
  - 反模式编程（意大利面代码、复制-黏贴编程、自负编程、……）
团队开发工具介绍
- 版本控制：Git、Mercury
- 缺陷管理：Gitlab、Redmine
- 敏捷闭环工具：禅道、JIRA
- 持续集成：Jenkins、Travis-CI
请参考《团队项目开发的问题和解决方案》。

项目选题和理解业务

选题范围设定
- CMS（用户端）：新闻聚合网站、问答/分享社区、影评/书评网站等。
- MIS（用户端+管理端）：KMS、KPI考核系统、HRS、CRM系统、供应链系统、仓储管理系统等。
- App后台（管理端+数据接口）：二手交易类、报刊杂志类、小众电商类、新闻资讯类、旅游类、社交类、阅读类等。
- 其他类型：自身行业背景和工作经验、业务容易理解和把控。
需求理解、模块划分和任务分配
- 需求理解：头脑风暴和竞品分析。
- 模块划分：画思维导图（XMind），每个模块是一个枝节点，每个具体的功能是一个叶节点（用动词表述），需要确保每个叶节点无法再生出新节点，确定每个叶子节点的重要性、优先级和工作量。
- 任务分配：由项目负责人根据上面的指标为每个团队成员分配任务。

制定项目进度表（每日更新）

模块	功能	人员	状态	完成	工时	计划开始	计划结束	备注
评论	添加评论	王大锤	正在进行	50%	4	2018/8/7	2018/8/7
	删除评论	王大锤	等待	0%	2	2018/8/7	2018/8/7
	查看评论	白元芳	正在进行	20%	4	2018/8/7	2018/8/7	需要进行代码审查
	评论投票	白元芳	等待	0%	4	2018/8/8	2018/8/8

OOAD和数据库设计

UML（统一建模语言）的类图
通过模型创建表（正向工程），例如在Django项目中可以通过下面的命令创建二维表。
1 2

python manage.py makemigrations app python manage.py migrate
使用PowerDesigner绘制物理模型图。
通过数据表创建模型（反向工程），例如在Django项目中可以通过下面的命令生成模型。
1

python manage.py inspectdb > app/models.py

第92天：Docker容器技术详解

Docker简介
安装Docker
使用Docker创建容器（Nginx、MySQL、Redis、Gitlab、Jenkins）
构建Docker镜像（Dockerfile的编写和相关指令）
容器编排（Docker-compose）
集群管理（Kubernetes）

第93天：MySQL性能优化

基本原则
InnoDB引擎
索引的使用和注意事项
数据分区
SQL优化
配置优化
架构优化

第94天：网络API接口设计

设计原则
- 关键问题
- 其他问题
文档撰写

第95天：[使用Django开发商业项目](./Day91-100/95.使用Django开发商业项目.md)

项目开发中的公共问题

数据库的配置（多数据库、主从复制、数据库路由）
缓存的配置（分区缓存、键设置、超时设置、主从复制、故障恢复（哨兵））
日志的配置
分析和调试（Django-Debug-ToolBar）
好用的Python模块（日期计算、图像处理、数据加密、三方API）

REST API设计

项目中的重点难点剖析

使用缓存缓解数据库压力 - Redis
使用消息队列做解耦合和削峰 - Celery + RabbitMQ

第96天：软件测试和自动化测试

单元测试

测试的种类
编写单元测试（unittest、pytest、nose2、tox、ddt、……）
测试覆盖率（coverage）

Django项目部署

部署前的准备工作
- 关键设置（SECRET_KEY / DEBUG / ALLOWED_HOSTS / 缓存 / 数据库）
- HTTPS / CSRF_COOKIE_SECUR / SESSION_COOKIE_SECURE
- 日志相关配置
Linux常用命令回顾
Linux常用服务的安装和配置
uWSGI/Gunicorn和Nginx的使用
- Gunicorn和uWSGI的比较
  - 对于不需要大量定制化的简单应用程序，Gunicorn是一个不错的选择，uWSGI的学习曲线比Gunicorn要陡峭得多，Gunicorn的默认参数就已经能够适应大多数应用程序。
  - uWSGI支持异构部署。
  - 由于Nginx本身支持uWSGI，在线上一般都将Nginx和uWSGI捆绑在一起部署，而且uWSGI属于功能齐全且高度定制的WSGI中间件。
  - 在性能上，Gunicorn和uWSGI其实表现相当。
使用虚拟化技术（Docker）部署测试环境和生产环境

性能测试

AB的使用
SQLslap的使用
sysbench的使用

自动化测试

使用Shell和Python进行自动化测试
使用Selenium实现自动化测试
- Selenium IDE
- Selenium WebDriver
- Selenium Remote Control
测试工具Robot Framework介绍

第97天：电商网站技术要点剖析

商业模式和需求要点
物理模型设计
第三方登录
缓存预热和查询缓存
购物车的实现
支付功能集成
秒杀和超卖问题
静态资源管理
全文检索方案

第98天：项目部署上线和性能调优

MySQL数据库调优
Web服务器性能优化
- Nginx负载均衡配置
- Keepalived实现高可用
代码性能调优
- 多线程
- 异步化
静态资源访问优化
- 云存储
- CDN

第99天：面试中的公共问题

计算机基础
Python基础
Web框架相关
爬虫相关问题
数据分析
项目相关

第100天 - 补充内容

面试宝典
- Python 面试宝典
- SQL 面试宝典（数据分析师）
- 商业分析面试宝典
- 机器学习面试宝典
机器学习数学基础
深度学习
- 计算机视觉
- 大语言模型

teable

Fri, 02 May 2025 15:28:12 +0800

teableio/teable

Manage Your Data & Connect Your Team

Teable uses a simple, spreadsheet-like interface to create powerful database applications. Collaborate with your team in real-time, and scale to millions of rows

Try out Teable using our hosted version at teable.io

Quick Guide

Looking for a quick experience? Select a scenario from the template center and click “Use this template”.
Seeking high performance? Try the 1 million rows demo to feel the speed of Teable.
Interested in deploying it yourself? Click Deploy on Railway

✨Features

🍺 Feature Packed

Everything you need, right out of the box:

Aggregation
Attachments Preview
Batch Editing
Charts
Comments
Custom Columns
Field Conversion
Filtering
Formatting
Formula Support
Grouping
History
Import/Export
Millions of Rows
Plugins
Real-time
Search
Sorting
SQL Query
Undo/Redo
Validation

🏞️ Multiple Views

Visualize and interact with data in various ways best suited for their specific tasks.

Grid View
Form View
Kanban View
Gallery View
Calendar View

📊 Charts & Dashboard

More features coming soon, see our Roadmap

Structure

.
├── apps (AGPL 3.0)
│   ├── nextjs-app          (front-end)
│   └── nestjs-backend      (backend)
├── packages (MIT)
│   ├── common-i18n         (locales)
│   ├── core                (share code and interface)
│   ├── sdk                 (sdk for extensions)
│   ├── db-main-prisma      (schema, migrations, prisma client)
│   ├── eslint-config-bases (to shared eslint configs)
│   └── ui-lib              (ui component)
└── plugins (AGPL 3.0)      (custom plugins)

Deploy

Deploy With Docker

1
2

cd dockers/examples/standalone/
docker-compose up -d

for more details, see install teable

One Click Deployment

These platforms are easy to deploy with one click and come with free credits.

Development

1. Initialize

# Enabling the Help Management Package Manager
corepack enable

# Install project dependencies
pnpm install

2. Select Database

we currently support sqlite (dev only) and postgres, you can switch between them by running the following command

`1`	`make switch-db-mode`

3. Custom Environment Variables（Optional）

1
2

cd apps/nextjs-app
cp .env.development .env.development.local

4. Run Dev Server

you just need to start backend, it will start next server for frontend automatically, file change will be auto reload

1
2

cd apps/nestjs-backend
pnpm dev

By default, the plugin development server is not started. To preview and develop plugins, run:

# build packages
pnpm build:packages

# start plugin development server
cd plugins
pnpm dev

This will start the plugin development server on port 3002.

Why Teable?

No-code tools have significantly speed up how we get things done, allowing non-tech users to build amazing apps and changing the way many work and live. People like using spreadsheet-like UI to handle their data because it’s easy, flexible, and great for team collaboration. They also prefer designing their app screens without being stuck with clunky templates.

Giving non-techy people the ability to create their software sounds exciting. But that’s just the start:

As businesses expand, their data needs intensify. No one wishes to hear that once their orders reach 100k, they’ll outgrow their current interface. Yet, many no-code platforms falter at such scales.
Most no-code platforms are cloud-based. This means your important data sits with the provider, and switching to another platform can be a headache.
Sometimes, no-code tools can’t do what you want because of their limitations, leaving users stuck.
If a tool becomes essential, you’ll eventually need some tech expertise. But developers often find these platforms tricky.
Maintaining systems with complex setups can be hard for developers, especially if these aren’t built using common software standards.
Systems that don’t use these standards might need revamping or replacing, costing more in the long run. It might even mean ditching the no-code route and going back to traditional coding.

What We Think the Future Of No-code Products Look Like

An interface that anyone can use to build applications easily.
Easy access to data, letting users grab, move, and reuse their information as they wish.
Data privacy and choice, whether that’s in the cloud, on-premise, or even just on your local.
It needs to work for developers too, not just non-tech users.
It should handle lots of data, so it can grow with your business.
Flexibility to integrate with other software, combining strengths to get the job done.
Last, native AI integration to takes usability to the next level.

In essence, Teable isn’t just another no-code solution, it’s a comprehensive answer to the evolving demands of modern software development, ensuring that everyone, regardless of their technical proficiency, has a platform tailored to their needs.

License

Teable Community Edition (CE) is free for self-hosting under the AGPL license. See ./LICENSE for details.

Teable Enterprise Edition (EE) includes advanced features such as AI, authority matrix, automation and advanced admin. For detailed information and pricing, please visit pricing.

scylladb

Thu, 17 Apr 2025 15:30:57 +0800

scylladb/scylladb

Scylla

What is Scylla?

Scylla is the real-time big data database that is API-compatible with Apache Cassandra and Amazon DynamoDB. Scylla embraces a shared-nothing approach that increases throughput and storage capacity to realize order-of-magnitude performance improvements and reduce hardware costs.

For more information, please see the ScyllaDB web site.

Build Prerequisites

Scylla is fairly fussy about its build environment, requiring very recent versions of the C++23 compiler and of many libraries to build. The document HACKING.md includes detailed information on building and developing Scylla, but to get Scylla building quickly on (almost) any build machine, Scylla offers a frozen toolchain, This is a pre-configured Docker image which includes recent versions of all the required compilers, libraries and build tools. Using the frozen toolchain allows you to avoid changing anything in your build machine to meet Scylla’s requirements - you just need to meet the frozen toolchain’s prerequisites (mostly, Docker or Podman being available).

Building Scylla

Building Scylla with the frozen toolchain dbuild is as easy as:

1
2
3

$ git submodule update --init --force --recursive
$ ./tools/toolchain/dbuild ./configure.py
$ ./tools/toolchain/dbuild ninja build/release/scylla

For further information, please see:

Developer documentation for more information on building Scylla.
Build documentation on how to build Scylla binaries, tests, and packages.
Docker image build documentation for information on how to build Docker images.

Running Scylla

To start Scylla server, run:

`1`	`$ ./tools/toolchain/dbuild ./build/release/scylla --workdir tmp --smp 1 --developer-mode 1`

This will start a Scylla node with one CPU core allocated to it and data files stored in the tmp directory. The --developer-mode is needed to disable the various checks Scylla performs at startup to ensure the machine is configured for maximum performance (not relevant on development workstations). Please note that you need to run Scylla with dbuild if you built it with the frozen toolchain.

For more run options, run:

`1`	`$ ./tools/toolchain/dbuild ./build/release/scylla --help`

Testing

See test.py manual.

Scylla APIs and compatibility

By default, Scylla is compatible with Apache Cassandra and its API - CQL. There is also support for the API of Amazon DynamoDB™, which needs to be enabled and configured in order to be used. For more information on how to enable the DynamoDB™ API in Scylla, and the current compatibility of this feature as well as Scylla-specific extensions, see Alternator and Getting started with Alternator.

Documentation

Documentation can be found here. Seastar documentation can be found here. User documentation can be found here.

Training

Training material and online courses can be found at Scylla University. The courses are free, self-paced and include hands-on examples. They cover a variety of topics including Scylla data modeling, administration, architecture, basic NoSQL concepts, using drivers for application development, Scylla setup, failover, compactions, multi-datacenters and how Scylla integrates with third-party applications.

Contributing to Scylla

If you want to report a bug or submit a pull request or a patch, please read the contribution guidelines.

If you are a developer working on Scylla, please read the developer guidelines.

Contact

The community forum and Slack channel are for users to discuss configuration, management, and operations of ScyllaDB.
The developers mailing list is for developers and people interested in following the development of ScyllaDB to discuss technical topics.

supabase-mcp

Thu, 10 Apr 2025 15:27:28 +0800

supabase-community/supabase-mcp

Supabase MCP Server

Connect your Supabase projects to Cursor, Claude, Windsurf, and other AI assistants.

The Model Context Protocol (MCP) standardizes how Large Language Models (LLMs) talk to external services like Supabase. It connects AI assistants directly with your Supabase project and allows them to perform tasks like managing tables, fetching config, and querying data. See the full list of tools.

Prerequisites

You will need Node.js installed on your machine. You can check this by running:

node -v

If you don’t have Node.js installed, you can download it from nodejs.org.

Setup

1. Personal access token (PAT)

First, go to your Supabase settings and create a personal access token. Give it a name that describes its purpose, like “Cursor MCP Server”.

This will be used to authenticate the MCP server with your Supabase account. Make sure to copy the token, as you won’t be able to see it again.

2. Configure MCP client

Next, configure your MCP client (such as Cursor) to use this server. Most MCP clients store the configuration as JSON in the following format:

{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": [
        "-y",
        "@supabase/mcp-server-supabase@latest",
        "--access-token",
        "<personal-access-token>"
      ]
    }
  }
}

Replace <personal-access-token> with the token you created in step 1. Alternatively you can omit --access-token and instead set the SUPABASE_ACCESS_TOKEN environment variable to your personal access token (you will need to restart your MCP client after setting this). This allows you to keep your token out of version control if you plan on committing this configuration to a repository.

If you are on Windows, you will need to prefix the command. If your MCP client doesn’t accept JSON, the direct CLI command is:

`1`	`npx -y @supabase/mcp-server-supabase@latest --access-token=<personal-access-token>`

Note: Do not run this command directly - this is meant to be executed by your MCP client in order to start the server. npx automatically downloads the latest version of the MCP server from npm and runs it in a single command.

Windows

On Windows, you will need to prefix the command with cmd /c:

{
  "mcpServers": {
    "supabase": {
      "command": "cmd",
      "args": [
        "/c",
        "npx",
        "-y",
        "@supabase/mcp-server-supabase@latest",
        "--access-token",
        "<personal-access-token>"
      ]
    }
  }
}

or with wsl if you are running Node.js inside WSL:

{
  "mcpServers": {
    "supabase": {
      "command": "wsl",
      "args": [
        "npx",
        "-y",
        "@supabase/mcp-server-supabase@latest",
        "--access-token",
        "<personal-access-token>"
      ]
    }
  }
}

Make sure Node.js is available in your system PATH environment variable. If you are running Node.js natively on Windows, you can set this by running the following commands in your terminal.

Get the path to npm:
1

npm config get prefix
Add the directory to your PATH:
1

setx PATH "%PATH%;<path-to-dir>"
Restart your MCP client.

Tools

Note: This server is pre-1.0, so expect some breaking changes between versions. Since LLMs will automatically adapt to the tools available, this shouldn’t affect most users.

The following Supabase tools are available to the LLM:

Project Management

list_projects: Lists all Supabase projects for the user.
get_project: Gets details for a project.
create_project: Creates a new Supabase project.
pause_project: Pauses a project.
restore_project: Restores a project.
list_organizations: Lists all organizations that the user is a member of.
get_organization: Gets details for an organization.

Database Operations

list_tables: Lists all tables within the specified schemas.
list_extensions: Lists all extensions in the database.
list_migrations: Lists all migrations in the database.
apply_migration: Applies a SQL migration to the database. SQL passed to this tool will be tracked within the database, so LLMs should use this for DDL operations (schema changes).
execute_sql: Executes raw SQL in the database. LLMs should use this for regular queries that don’t change the schema.
get_logs: Gets logs for a Supabase project by service type (api, postgres, edge functions, auth, storage, realtime). LLMs can use this to help with debugging and monitoring service performance.

Project Configuration

get_project_url: Gets the API URL for a project.
get_anon_key: Gets the anonymous API key for a project.

Branching (Experimental, requires a paid plan)

create_branch: Creates a development branch with migrations from production branch.
list_branches: Lists all development branches.
delete_branch: Deletes a development branch.
merge_branch: Merges migrations and edge functions from a development branch to production.
reset_branch: Resets migrations of a development branch to a prior version.
rebase_branch: Rebases development branch on production to handle migration drift.

Development Tools

generate_typescript_types: Generates TypeScript types based on the database schema. LLMs can save this to a file and use it in their code.

Cost Confirmation

get_cost: Gets the cost of a new project or branch for an organization.
confirm_cost: Confirms the user’s understanding of new project or branch costs. This is required to create a new project or branch.

Other MCP servers

`@supabase/mcp-server-postgrest`

The PostgREST MCP server allows you to connect your own users to your app via REST API. See more details on its project README.

Resources

Model Context Protocol: Learn more about MCP and its capabilities.

License

This project is licensed under Apache 2.0. See the LICENSE file for details.

liam

Tue, 08 Apr 2025 15:29:27 +0800

liam-hq/liam

Automatically generates beautiful and easy-to-read ER diagrams from your database.

Website • Documentation • Roadmap

What’s Liam ERD?

Liam ERD generates beautiful, interactive ER diagrams from your database. Whether you’re working on public or private repositories, Liam ERD helps you visualize complex schemas with ease.

Beautiful UI & Interactive: A clean design and intuitive features (like panning, zooming, and filtering) make it easy to understand even the most complex databases.
Simple Reverse Engineering: Seamlessly turn your existing database schemas into clear, readable diagrams.
Effortless Setup: Get started with zero configuration—just provide your schema, and you’re good to go.
High Performance: Optimized for both small and large projects, easily handling 100+ tables.
Fully Open-Source: Contribute to the project and shape Liam ERD to fit your needs.

Quick Start

For Public Repositories

Insert liambx.com/erd/p/ into your schema file’s URL:

1
2
3

# Original: https://github.com/user/repo/blob/master/db/schema.rb
# Modified: https://liambx.com/erd/p/github.com/user/repo/blob/master/db/schema.rb
                  👾^^^^^^^^^^^^^^^^👾

For Private Repositories

Run the interactive setup:

`1`	`npx @liam-hq/cli init`

If you find this project helpful, please give it a star! ⭐
Your support helps us reach a wider audience and continue development.

Documentation

Check out the full documentation on the website.

Roadmap

See what we’re working on and what’s coming next on our roadmap.

Contributing

Refer to our contribution guidelines and Code of Conduct for contributors.

Contributors

License

Liam ERD is licensed under the Apache License Version 2.0.

Licenses for third-party packages can be found in docs/packages-license.md.