open-index/open-npm huggingface dataset:
npm package: @flinj/client
Description: | :construction: This project is still in development. You should use it with caution. | | ------------------------------------------------------------------------------------ |
Author: LacheRo`
Latest version: 1.1.0

# @flinj/client

| :construction: This project is still in development. You should use it with caution. |
| ------------------------------------------------------------------------------------ |

The fasest way to build REST API

![Flinching](https://media.giphy.com/media/TpXiNmXLdpOaEENYci/giphy.gif)

## Prerequisite

Install [@flinj/server](https://www.npmjs.com/package/@flinj/server) on your server

## Installation

```bash
npm i @flinj/client
```

navigate to your client directory and run

```base
npx flinj ../relative/path/to/backend/controllers
```

**Remember**
Everytime you create new controller on your server you need to run the command above

## Usage

```js
import { createClient } from '@flinj/client';

export const client = createClient({
	baseURL: '/api',
	headers: {
		authorization: `Bearer ${process.env.API_KEY}`,
	},
});

const user = await client.users.POST({
	name: 'Israel',
	email: 'test@gmail.com',
	password: '123456',
});
```

## TODO

- [x] support multi request params
- [x] adjust to work with the new changes of @flinj/server
npm package: @flink-app/gemini-adapter
Description: Google Gemini adapter for Flink AI framework
Author: Frost Digital
Latest version: 2.0.0-alpha.86

# @flink-app/gemini-adapter

Google Gemini adapter for the [Flink AI framework](https://github.com/FrostDigital/flink-framework).

## Installation

```bash
npm install @flink-app/gemini-adapter @google/generative-ai
```

## Usage

```typescript
import { GeminiAdapter } from "@flink-app/gemini-adapter";
import { FlinkApp } from "@flink-app/flink";

const app = new FlinkApp({
  ai: {
    llms: {
      default: new GeminiAdapter({
        apiKey: process.env.GOOGLE_AI_API_KEY!,
        model: "gemini-2.0-flash",
      }),
    },
  },
});
```

## Configuration

| Option  | Type      | Required | Description                                                        |
|---------|-----------|----------|--------------------------------------------------------------------|
| apiKey  | `string`  | Yes      | Google AI API key                                                  |
| model   | `string`  | Yes      | Gemini model name (e.g. `"gemini-2.0-flash"`, `"gemini-1.5-pro"`) |
| debug   | `boolean` | No       | Enable debug logging (default: `false`)                            |

## Supported Models

- `gemini-2.0-flash` — Fast, cost-effective (recommended default)
- `gemini-1.5-pro` — High capability, longer context
- `gemini-1.5-flash` — Fast, balanced capability
- `gemini-2.5-pro-preview-03-25` — Latest preview model

## Features

- ✅ Tool calling support
- ✅ Streaming responses (SSE / NDJSON)
- ✅ Alternating turn enforcement (consecutive same-role messages are merged)
- ✅ System instruction handling
- ✅ JSON Schema sanitization for Gemini compatibility
- ✅ Token usage tracking
- ✅ Debug logging

## Using with FlinkAgent

```typescript
import { FlinkAgent } from "@flink-app/flink";
import { GeminiAdapter } from "@flink-app/gemini-adapter";

export default class CarAgent extends FlinkAgent<AppContext> {
  instructions = "You are a helpful car assistant.";
  llm = new GeminiAdapter({
    apiKey: process.env.GOOGLE_AI_API_KEY!,
    model: "gemini-2.0-flash",
  });
}
```

## License

MIT
npm package: @flink-app/google-sheets-plugin
Description: Flink plugin for reading and writing Google Sheets using service account authentication
Author: joel@frost.se
Latest version: 2.0.0-alpha.86

# @flink-app/google-sheets-plugin

Read and write Google Sheets from a Flink app using service account authentication.

## Prerequisites

1. Create a service account in [Google Cloud Console](https://console.cloud.google.com/) → IAM & Admin → Service Accounts
2. Enable the **Google Sheets API** for your project
3. Share your spreadsheet with the service account email (Editor access)

## Register the plugin

```typescript
import { googleSheetsPlugin, GoogleSheetsPluginCtx } from "@flink-app/google-sheets-plugin";

interface AppCtx extends FlinkContext<GoogleSheetsPluginCtx> {
    repos: {};
}

new FlinkApp<AppCtx>({
    plugins: [
        googleSheetsPlugin({
            spreadsheetId: process.env.GOOGLE_SPREADSHEET_ID!,
            credentials: {
                clientEmail: process.env.GOOGLE_SERVICE_ACCOUNT_EMAIL!,
                privateKey: process.env.GOOGLE_PRIVATE_KEY!,
            },
        }),
    ],
});
```

The private key accepts a raw PEM string (with `\n`) or a base64-encoded service account JSON blob.

## Usage

Access the API via `ctx.plugins.googleSheets`. Use `.sheet("Title")` or `.sheetByIndex(n)` to scope operations to a specific sheet.

```typescript
// Read all rows
const rows = await ctx.plugins.googleSheets.sheet("Tasks").getRows();
// [{ rowIndex: 0, data: { title: "Fix bug", status: "pending" } }, ...]

// Append a row
const row = await ctx.plugins.googleSheets.sheet("Tasks").appendRow({
    title: "New task",
    status: "pending",
});

// Update a row
await ctx.plugins.googleSheets.sheet("Tasks").updateRow(row.rowIndex, {
    status: "completed",
});

// Delete a row
await ctx.plugins.googleSheets.sheet("Tasks").deleteRow(row.rowIndex);

// Spreadsheet metadata
const info = await ctx.plugins.googleSheets.getInfo();
// { title, spreadsheetId, sheetCount }
```

Rows are plain objects: `{ rowIndex: number, data: Record<string, string> }` where keys are column headers.

## Dynamic credentials

Load credentials from the database at startup instead of env vars:

```typescript
googleSheetsPlugin({
    loadCredentials: async (ctx) => {
        const config = await ctx.repos.configRepo.getOne({ key: "google" });
        return {
            credentials: {
                clientEmail: config.serviceAccountEmail,
                privateKey: config.privateKey,
            },
            spreadsheetId: config.spreadsheetId,
        };
    },
});
```

## AI tool

A generic `GoogleSheetsTool` is included for use with Flink agents. It supports `getRows`, `appendRow`, `updateRow`, `deleteRow`, and `getInfo` operations.

```typescript
import GoogleSheetsTool, { Tool } from "@flink-app/google-sheets-plugin/tools/GoogleSheetsTool";

class MyAgent extends FlinkAgent<AppCtx> {
    tools = [{ ...Tool, handler: GoogleSheetsTool }];
}
```
npm package: @flink-app/whatsapp-plugin
Description: Flink plugin for bi-directional WhatsApp messaging via Cloud API with auto-discovered WhatsappHandler files
Author: joel@frost.se
Latest version: 2.0.0-alpha.86

# @flink-app/whatsapp-plugin

Bi-directional WhatsApp messaging plugin for [Flink](https://github.com/FrostDigital/flink-framework) via the WhatsApp Cloud API. No external SDK — uses native `fetch`.

## Features

- Auto-discovered `WhatsappHandler` files via Flink's compiler extension
- Route matching by message type, sender, text pattern, and connection
- Send text, templates, images, documents, interactive buttons/lists, locations, reactions
- Multi-connection support (multiple WhatsApp Business phone numbers)
- Webhook signature verification (HMAC-SHA256)
- Message status tracking (sent, delivered, read, failed)
- 24-hour conversation window awareness with template message support
- Markdown to WhatsApp formatting converter
- CLI tool for sending test messages

## Quick Start

```bash
pnpm add @flink-app/whatsapp-plugin
```

```js
// flink.config.js
const { compilerPlugin } = require("@flink-app/whatsapp-plugin/compiler");
module.exports = { compilerPlugins: [compilerPlugin()] };
```

```typescript
// src/index.ts
import { whatsappPlugin } from "@flink-app/whatsapp-plugin";

new FlinkApp<Ctx>({
    plugins: [
        whatsappPlugin<Ctx>({
            connection: {
                accessToken: process.env.WHATSAPP_ACCESS_TOKEN!,
                phoneNumberId: process.env.WHATSAPP_PHONE_NUMBER_ID!,
                verifyToken: process.env.WHATSAPP_VERIFY_TOKEN!,
                appSecret: process.env.WHATSAPP_APP_SECRET!,
            },
        }),
    ],
});
```

```typescript
// src/whatsapp-handlers/HandleText.ts
import { WhatsappHandler, WhatsappRouteProps } from "@flink-app/whatsapp-plugin";

export const Route: WhatsappRouteProps = { type: "text" };

const handler: WhatsappHandler<Ctx> = async ({ message, whatsapp }) => {
    await whatsapp.reply(message, `Echo: ${message.text}`);
};

export default handler;
```

## Documentation

See the [skill documentation](../../skills/flink-whatsapp-plugin/SKILL.md) for complete usage guide including routing, multi-connection setup, template messages, interactive messages, media handling, and more.

## Meta App Setup

1. Create a Meta App at [developers.facebook.com](https://developers.facebook.com)
2. Add the WhatsApp product
3. Configure webhook URL to `https://your-domain.com/webhooks/whatsapp`
4. Subscribe to the `messages` webhook field
5. Generate a permanent access token via a System User

## CLI

```bash
pnpm exec flink-whatsapp send --token <token> --phone-id <id> --to <number> "Hello!"
```

## License

MIT
npm package: @flinkhouse/bailian-agent
Description: MCP server for bailian agent
Author: flinkhouse
Latest version: 1.0.0

# MCP 数据搜索工具

基于模型上下文协议 (Model Context Protocol, MCP) 实现的百炼的应用调用。

## 项目介绍

`bailian-agent` 是一个用于连接大语言模型与阿里云百炼知识库的桥接工具。它基于模型上下文协议 (MCP) 实现，允许AI模型通过工具调用的方式查询和检索存储在百炼知识库中的信息。

## 功能特点

- 提供标准化的MCP接口，兼容支持工具调用的AI模型
- 支持向阿里云百炼知识库发送查询请求
- 将百炼API响应格式化并返回给AI模型
- 作为独立的服务运行，易于集成到现有AI应用中

## 安装方法

```bash
# 使用npm安装
npm install @flinkhouse/bailian-agent

# 或者使用yarn
yarn add @flinkhouse/bailian-agent
```

## 使用方法

### 命令行使用

```bash
mcp-bailian-agent <app_id> <api_key> <model_description>
```

参数说明：
- `app_id`: 百炼应用的ID
- `api_key`: 百炼API访问密钥
- `model_description`: 工具描述信息，会显示在AI模型的工具列表中

### 在AI应用中集成

1. 启动`bailian-agent`服务
2. 配置AI模型使用MCP协议连接到该服务
3. 通过工具调用的方式，使用`callBailianAgent`函数查询百炼知识库

## 示例

当AI模型需要从百炼知识库检索信息时，可以通过如下方式调用:

```javascript
// AI模型工具调用示例
callBailianAgent({
  query: "查询关键词或问题"
})
```

## 依赖项

- @modelcontextprotocol/sdk: MCP协议SDK
- axios: HTTP请求客户端
- zod-to-json-schema: Schema转换工具

## 许可证

MIT
npm package: @flinkhouse/server-aws-kb-retrieval
Description: MCP server for AWS Knowledge Base retrieval using Bedrock Agent Runtime
Author: flinkhouse
Latest version: 0.6.3

# AWS Knowledge Base Retrieval MCP Server

An MCP server implementation for retrieving information from the AWS Knowledge Base using the Bedrock Agent Runtime.

## Features

- **RAG (Retrieval-Augmented Generation)**: Retrieve context from the AWS Knowledge Base based on a query and a Knowledge Base ID.
- **Supports multiple results retrieval**: Option to retrieve a customizable number of results.

## Tools

- **retrieve_from_aws_kb**
  - Perform retrieval operations using the AWS Knowledge Base.
  - Inputs:
    - `query` (string): The search query for retrieval.
    - `knowledgeBaseId` (string): The ID of the AWS Knowledge Base.
    - `n` (number, optional): Number of results to retrieve (default: 3).

## Configuration

### Setting up AWS Credentials

1. Obtain AWS access key ID, secret access key, and region from the AWS Management Console.
2. Ensure these credentials have appropriate permissions for Bedrock Agent Runtime operations.

### Usage with Claude Desktop

Add this to your `claude_desktop_config.json`:

#### Docker

```json
{
  "mcpServers": {
    "aws-kb-retrieval": {
      "command": "docker",
      "args": [ "run", "-i", "--rm", "-e", "AWS_ACCESS_KEY_ID", "-e", "AWS_SECRET_ACCESS_KEY", "-e", "AWS_REGION", "mcp/aws-kb-retrieval-server" ],
      "env": {
        "AWS_ACCESS_KEY_ID": "YOUR_ACCESS_KEY_HERE",
        "AWS_SECRET_ACCESS_KEY": "YOUR_SECRET_ACCESS_KEY_HERE",
        "AWS_REGION": "YOUR_AWS_REGION_HERE"
      }
    }
  }
}
```

```json
{
  "mcpServers": {
    "aws-kb-retrieval": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-aws-kb-retrieval"
      ],
      "env": {
        "AWS_ACCESS_KEY_ID": "YOUR_ACCESS_KEY_HERE",
        "AWS_SECRET_ACCESS_KEY": "YOUR_SECRET_ACCESS_KEY_HERE",
        "AWS_REGION": "YOUR_AWS_REGION_HERE"
      }
    }
  }
}
```

## Building

Docker: 

```sh
docker build -t mcp/aws-kb-retrieval -f src/aws-kb-retrieval-server/Dockerfile . 
```

## License

This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.

This README assumes that your server package is named `@modelcontextprotocol/server-aws-kb-retrieval`. Adjust the package name and installation details if they differ in your setup. Also, ensure that your server script is correctly built and that all dependencies are properly managed in your `package.json`.
npm package: @flinkhouse/server-brave-search
Description: MCP server for Brave Search API integration
Author: flinkhouse
Latest version: 0.6.3

# Brave Search MCP Server

An MCP server implementation that integrates the Brave Search API, providing both web and local search capabilities.

## Features

- **Web Search**: General queries, news, articles, with pagination and freshness controls
- **Local Search**: Find businesses, restaurants, and services with detailed information
- **Flexible Filtering**: Control result types, safety levels, and content freshness
- **Smart Fallbacks**: Local search automatically falls back to web when no results are found

## Tools

- **brave_web_search**
  - Execute web searches with pagination and filtering
  - Inputs:
    - `query` (string): Search terms
    - `count` (number, optional): Results per page (max 20)
    - `offset` (number, optional): Pagination offset (max 9)

- **brave_local_search**
  - Search for local businesses and services
  - Inputs:
    - `query` (string): Local search terms
    - `count` (number, optional): Number of results (max 20)
  - Automatically falls back to web search if no local results found


## Configuration

### Getting an API Key
1. Sign up for a [Brave Search API account](https://brave.com/search/api/)
2. Choose a plan (Free tier available with 2,000 queries/month)
3. Generate your API key [from the developer dashboard](https://api.search.brave.com/app/keys)

### Usage with Claude Desktop
Add this to your `claude_desktop_config.json`:

### Docker

```json
{
  "mcpServers": {
    "brave-search": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "BRAVE_API_KEY",
        "mcp/brave-search"
      ],
      "env": {
        "BRAVE_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}
```

### NPX

```json
{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-brave-search"
      ],
      "env": {
        "BRAVE_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}
```


## Build

Docker build:

```bash
docker build -t mcp/brave-search:latest -f src/brave-search/Dockerfile .
```

## License

This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.
npm package: @flinkhouse/server-everart
Description: MCP server for EverArt API integration
Author: flinkhouse
Latest version: 0.6.3

# EverArt MCP Server

Image generation server for Claude Desktop using EverArt's API.

## Install
```bash
npm install
export EVERART_API_KEY=your_key_here
```

## Config
Add to Claude Desktop config:

### Docker
```json
{
  "mcpServers": {
    "everart": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "EVERART_API_KEY", "mcp/everart"],
      "env": {
        "EVERART_API_KEY": "your_key_here"
      }
    }
  }
}
```

### NPX

```json
{
  "mcpServers": {
    "everart": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-everart"],
      "env": {
        "EVERART_API_KEY": "your_key_here"
      }
    }
  }
}
```

## Tools

### generate_image
Generates images with multiple model options. Opens result in browser and returns URL.

Parameters:
```typescript
{
  prompt: string,       // Image description
  model?: string,       // Model ID (default: "207910310772879360")
  image_count?: number  // Number of images (default: 1)
}
```

Models:
- 5000: FLUX1.1 (standard)
- 9000: FLUX1.1-ultra
- 6000: SD3.5
- 7000: Recraft-Real
- 8000: Recraft-Vector

All images generated at 1024x1024.

Sample usage:
```javascript
const result = await client.callTool({
  name: "generate_image",
  arguments: {
    prompt: "A cat sitting elegantly",
    model: "7000",
    image_count: 1
  }
});
```

Response format:
```
Image generated successfully!
The image has been opened in your default browser.

Generation details:
- Model: 7000
- Prompt: "A cat sitting elegantly"
- Image URL: https://storage.googleapis.com/...

You can also click the URL above to view the image again.
```

## Building w/ Docker

```sh
docker build -t mcp/everart -f src/everart/Dockerfile . 
```
npm package: @flinkhouse/server-flinkmanager
Description: MCP server for managing Flink standalone clusters
Author: flinkhouse
Latest version: 0.1.1

# Flink Manager MCP服务器

这是一个Model Context Protocol (MCP) 服务器，用于管理本地Flink standalone集群。通过这个工具，AI助手可以帮助你启动、停止Flink集群并检查其状态。

## 功能

- 启动Flink standalone集群
- 停止Flink standalone集群
- 获取集群当前状态（运行中/已停止/部分运行）
- 查看集群配置

## 先决条件

- Node.js v18或更高版本
- 已安装的Apache Flink（standalone模式）
- 确保Flink的bin目录下有`start-cluster.sh`和`stop-cluster.sh`脚本

## 安装

```bash
npm install -g @modelcontextprotocol/server-flinkmanager
```

或者从源码构建：

```bash
git clone <repository-url>
cd servers/src/flinkmanager
npm install
npm run build
```

## 使用方法

### 启动服务器

```bash
npx -y @modelcontextprotocol/server-flinkmanager /path/to/flink/home
```

其中`/path/to/flink/home`是你Flink安装的根目录。

### 可用工具

服务器提供以下工具：

1. **start_cluster** - 启动Flink集群
   - 参数：`timeout`（可选，单位：秒，默认30秒）

2. **stop_cluster** - 停止Flink集群
   - 参数：`timeout`（可选，单位：秒，默认30秒）

3. **get_cluster_status** - 获取集群状态
   - 无参数

4. **get_cluster_config** - 获取集群配置
   - 参数：`configFile`（可选，指定配置文件名，如"flink-conf.yaml"）

## 示例

通过AI助手使用：

```
USER: 请启动我的Flink集群

AI: [使用start_cluster工具]
正在启动Flink集群...
Flink集群已成功启动。
Web UI可通过 http://localhost:8081 访问。

USER: 集群状态如何？

AI: [使用get_cluster_status工具]
Flink集群状态：
- 状态: 运行中
- JobManager: 运行中 (PID: 12345)
- TaskManagers: 2个运行中
- Web界面: http://localhost:8081 (可访问)

USER: 请停止集群

AI: [使用stop_cluster工具]
正在停止Flink集群...
Flink集群已成功停止。
```

## 故障排除

- 确保指定了正确的Flink目录
- 验证Flink安装是否完整
- 检查是否有足够的权限执行Flink脚本
- 如果集群启动后处于"部分"状态，可能需要手动检查TaskManager日志

## 许可证

MIT
npm package: @flinkhouse/server-google-maps
Description: MCP server for using the Google Maps API
Author: flinkhouse
Latest version: 0.6.3

# Google Maps MCP Server

MCP Server for the Google Maps API.

## Tools

1. `maps_geocode`
   - Convert address to coordinates
   - Input: `address` (string)
   - Returns: location, formatted_address, place_id

2. `maps_reverse_geocode`
   - Convert coordinates to address
   - Inputs:
     - `latitude` (number)
     - `longitude` (number)
   - Returns: formatted_address, place_id, address_components

3. `maps_search_places`
   - Search for places using text query
   - Inputs:
     - `query` (string)
     - `location` (optional): { latitude: number, longitude: number }
     - `radius` (optional): number (meters, max 50000)
   - Returns: array of places with names, addresses, locations

4. `maps_place_details`
   - Get detailed information about a place
   - Input: `place_id` (string)
   - Returns: name, address, contact info, ratings, reviews, opening hours

5. `maps_distance_matrix`
   - Calculate distances and times between points
   - Inputs:
     - `origins` (string[])
     - `destinations` (string[])
     - `mode` (optional): "driving" | "walking" | "bicycling" | "transit"
   - Returns: distances and durations matrix

6. `maps_elevation`
   - Get elevation data for locations
   - Input: `locations` (array of {latitude, longitude})
   - Returns: elevation data for each point

7. `maps_directions`
   - Get directions between points
   - Inputs:
     - `origin` (string)
     - `destination` (string)
     - `mode` (optional): "driving" | "walking" | "bicycling" | "transit"
   - Returns: route details with steps, distance, duration

## Setup

### API Key
Get a Google Maps API key by following the instructions [here](https://developers.google.com/maps/documentation/javascript/get-api-key#create-api-keys).

### Usage with Claude Desktop

Add the following to your `claude_desktop_config.json`:

#### Docker

```json
{
  "mcpServers": {
    "google-maps": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GOOGLE_MAPS_API_KEY",
        "mcp/google-maps"
      ],
      "env": {
        "GOOGLE_MAPS_API_KEY": "<YOUR_API_KEY>"
      }
    }
  }
}
```

### NPX

```json
{
  "mcpServers": {
    "google-maps": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-google-maps"
      ],
      "env": {
        "GOOGLE_MAPS_API_KEY": "<YOUR_API_KEY>"
      }
    }
  }
}
```

## Build

Docker build:

```bash
docker build -t mcp/google-maps -f src/google-maps/Dockerfile .
```

## License

This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.
npm package: @flinkhouse/server-postgres
Description: MCP server for interacting with PostgreSQL databases
Author: flinkhouse
Latest version: 0.6.3

# PostgreSQL

A Model Context Protocol server that provides read-only access to PostgreSQL databases. This server enables LLMs to inspect database schemas and execute read-only queries.

## Components

### Tools

- **query**
  - Execute read-only SQL queries against the connected database
  - Input: `sql` (string): The SQL query to execute
  - All queries are executed within a READ ONLY transaction

### Resources

The server provides schema information for each table in the database:

- **Table Schemas** (`postgres://<host>/<table>/schema`)
  - JSON schema information for each table
  - Includes column names and data types
  - Automatically discovered from database metadata

## Usage with Claude Desktop

To use this server with the Claude Desktop app, add the following configuration to the "mcpServers" section of your `claude_desktop_config.json`:

### Docker

* when running docker on macos, use host.docker.internal if the server is running on the host network (eg localhost)
* username/password can be added to the postgresql url with `postgresql://user:password@host:port/db-name`

```json
{
  "mcpServers": {
    "postgres": {
      "command": "docker",
      "args": [
        "run", 
        "-i", 
        "--rm", 
        "mcp/postgres", 
        "postgresql://host.docker.internal:5432/mydb"]
    }
  }
}
```

### NPX

```json
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost/mydb"
      ]
    }
  }
}
```

Replace `/mydb` with your database name.

## Building

Docker:

```sh
docker build -t mcp/postgres -f src/postgres/Dockerfile . 
```

## License

This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.
npm package: @flint-dev/cli
Description: Flint command-line entrypoint
Author: Aaron Escalona
Latest version: 0.2.4

# @flint-dev/cli

Flint command-line entrypoint.

## Install

```bash
npm install -g @flint-dev/cli
```

Or run without installing globally:

```bash
npx @flint-dev/cli --help
```

## Commands

- `flint tui`
- `flint gateway`
- `flint app-server`
- `flint pi-app-server`
npm package: @flint-dev/flint
Description: Flint command-line entrypoint
Author: Aaron Escalona
Latest version: 0.2.1

# @flint-dev/flint

Flint command-line entrypoint.

## Install

```bash
npm install -g @flint-dev/flint
```

Or run without installing globally:

```bash
npx @flint-dev/flint --help
```

## Commands

- `flint tui`
- `flint gateway`
- `flint app-server`
- `flint pi-app-server`
npm package: @flint-dev/tui
Description: Terminal UI for chatting with Flint app servers
Author: Aaron Escalona
Latest version: 0.2.2

# @flint-dev/tui

Terminal UI for Flint app servers.

## Run

```bash
flint-tui
```

Optional environment variables:

- `FLINT_PROJECT` working directory override (defaults to current directory)
- `FLINT_APP_SERVER_COMMAND` app server command (defaults to `claude-app-server`)
- `FLINT_APP_SERVER_ARGS` space-delimited args forwarded to app server