Content
<div align="center">
# Tool List
[](https://github.com/hexinfo/dat/releases/latest)
[](https://github.com/hexinfo/dat)
[](https://github.com/hexinfo/dat/releases/latest)
[](https://github.com/hexinfo/dat/blob/main/LICENSE)
[](https://openjdk.java.net/projects/jdk/17/)
[](https://maven.apache.org/)
[](https://deepwiki.com/hexinfo/dat)
[](https://zread.ai/hexinfo/dat)

</div>
---
> **[ English Version](./README-EN.md)**
---
## Project Vision
> We are entering a new era of generative artificial intelligence, where **language is the interface, and data is the fuel**.
DAT aims to solve the last mile problem of enterprise data query - allowing business personnel to directly dialogue with the database in natural language without writing complex SQL queries. Through the pre-modeled semantic layer, DAT ensures that AI can not only express confidently but also correctly.
DAT's core driving force is not entirely derived from the large language model's another intellectual explosion, but from the Askdata Agent workflow we designed for it.
Everything we do is essentially exchanging `“more accurate and complete knowledge”` ( **the main focus of current development** ) , `“more computing steps”` and `“longer thinking time”` for a crucial thing in the real business world - the `“high quality”` and `“certainty”` of results.
## Core Features
### Enterprise-level Architecture Design
- **Pluggable SPI Architecture** - Supports flexible expansion of multiple databases, LLM, and embedded models
- **Factory Mode Implementation** - Standardized component creation and management mechanism
- **Modular Design** - Clear separation of responsibilities, easy to maintain and expand
### Multi-database Support
- **MySQL** - Complete support, including connection pool and dialect conversion
- **PostgreSQL** - Enterprise-level database support
- **Oracle** - Traditional enterprise database compatibility
- **More databases** - Easily expand through SPI mechanism
### Intelligent Semantic SQL Generation
- **Natural Language Understanding** - Based on LLM's semantic parsing
- **SQL Dialect Conversion** - Automatically adapt to different database syntax
- **Semantic Model Binding** - Ensure query accuracy through predefined models
### Rich Semantic Modeling
- **Entities** - Primary key, foreign key relationship definition
- **Dimensions** - Time, classification, enumeration dimension support
- **Measures** - Aggregation function, calculation field definition
- **YAML Configuration** - Intuitive model definition method
### Vectorized Retrieval Enhancement
- **Content Storage** - SQL Q&A pairs, synonyms, business knowledge vectorization
- **Semantic Retrieval** - Intelligent matching based on Embedding model
- **Multi-storage Backends** - DuckDB, Weaviate, PGVector and other storage options
## System Architecture
```
┌─────────────────────────────────────────────────────────────┐
│ DAT Framework │
├─────────────────────────────────────────────────────────────┤
│ 🎯 DAT Language (Creation Layer) │
│ ├── 📝 Semantic Model Definition (YAML) │
│ ├── 🗃️ Data Model Configuration │
│ └── 🤖 Intelligent Agent Configuration │
├─────────────────────────────────────────────────────────────┤
│ ⚙️ DAT Engine (Execution Layer) │
│ ├── 🔤 Natural Language Understanding │ 📊 Semantic SQL Generation │ 🗄️ Data Query Execution │
│ ├── 🧠 LLM Call Management │ 🔍 Vector Retrieval Enhancement │ 📈 Result Formatting │
│ └── 🔌 SPI Component Management │ 🏭 Factory Mode Creation │ ⚡ Cache Optimization │
└─────────────────────────────────────────────────────────────┘
```
- 1. DAT CLI is used for local development, unit testing, and debugging. It can develop DAT intelligent question projects locally through IDE (vscode, idea, or eclipse), and `transform the prompt (context) project into a data project`.
Therefore, the development mode of DAT Project naturally fits with AI Coding tools (such as Cursor, Claude Code, etc.), helping to achieve a more intelligent and automated intelligent question development process.
- 2. DAT is not a platform but a `framework`; secondary developers can develop their own Web UI based on `dat-sdk`, which can be a web IDE, a drag-and-drop workflow, a list, or other interactive methods; or provide `OpenAPI` or `MCP` services.
- 3. This mode `allows data engineers or data analysts to develop intelligent question applications like software engineers develop applications`.
## Quick Start
### Environmental Requirements
- **Java 17+** - Recommended to use OpenJDK
- **Database** - MySQL / PostgreSQL / Oracle / DuckDB Choose one
- **LLM API** - OpenAI / Anthropic / Ollama / Gemini etc.
### ⚡ 5-minute Quick Experience
#### 1️⃣ Install DAT CLI
##### 🐧 Linux/macOS System
```bash
# Download the latest version
wget https://github.com/hexinfo/dat/releases/latest/download/dat-cli-0.7.2-full.tar.gz
# Decompress and configure environment variables
tar -xzf dat-cli-x.x.x.tar.gz
mv dat-cli-x.x.x dat-cli
export PATH=$PATH:$(pwd)/dat-cli/bin
```
##### 🪟 Windows System
1. Visit [Releases page](https://github.com/hexinfo/dat/releases/latest)
2. Download `dat-cli-x.x.x.tar.gz` file
3. Decompress using WinRAR, 7-Zip, or Windows built-in decompression tools
4. Add the decompressed `dat-cli\bin` directory to the system PATH environment variable:
- Right-click "This PC" → "Properties" → "Advanced system settings"
- Click "Environment Variables" → Edit "Path" variable
- Add DAT CLI's bin directory path
#### 2️⃣ Initialize Project
```bash
# Create a new DAT project
dat init
# Follow the prompts to input project information
# Project name: my-dat-project
# Description: My first intelligent question project
# Database type: mysql
```

> 💡 <strong style="color: orange;">Tip:</strong> If you don't have an existing database to access, or just want to query local CSV data, you can choose `duckdb` as the database when initializing the project, and it will create a 'duckdb' prefix local embedded data storage in the project's `.dat` directory.
#### 3️⃣ Configure Data Source
Edit the generated `dat_project.yaml`:
```yaml
version: 1
name: my-dat-project
description: My first intelligent question project
# Database configuration
db:
provider: mysql
configuration:
url: jdbc:mysql://localhost:3306/mydb
username: your_username
password: your_password
timeout: 1 min
# LLM configuration
llm:
provider: openai
configuration:
api-key: your-openai-api-key
model-name: gpt-4
base-url: https://api.openai.com/v1
# Embedding model configuration
embedding:
provider: bge-small-zh-v15-q
```
> 💡 <strong style="color: orange;">Tip:</strong> For more project configurations, please refer to `dat_project.yaml.template` under the project.
> 💡 <strong style="color: orange;">Tip:</strong>
>
> If you don't have existing data to use, you can execute the `seed` command to load the seed data into the database.
>
> ```
> # Load seed data
> dat seed -p ./my-dat-project
> ```
>
> Then skip step 4️⃣ and use the example semantic model in the initialized project for step 5️⃣ “Start Intelligent Question”.
#### 4️⃣ Create Semantic Model
Create `sales.yaml` in the `models/` directory:
```yaml
version: 1
semantic_models:
- name: sales_data
description: Sales data analysis model
model: ref('sales_table')
entities:
- name: product_id
description: Product ID
type: primary
dimensions:
- name: sale_date
description: Sales date
type: time
type_params:
time_granularity: day
- name: region
description: Sales region
type: categorical
enum_values:
- value: "North"
label: "North"
- value: "South"
label: "South"
measures:
- name: sales_amount
description: Sales amount
agg: sum
- name: order_count
description: Order quantity
agg: count
```
> 💡 <strong style="color: orange;">Tip:</strong> This is just an example. Please configure according to your real data.
> For more semantic model configuration instructions, please view the `MODEL_GUIDE.md` manual under the project.
#### 5️⃣ Start Intelligent Question
```bash
# Start interactive question
dat run -p ./my-dat-project -a default
# Or start API service
dat server openapi -p ./my-dat-project
```
Now you can query data with natural language!
```
💬 Please ask how much sales amount is in the North last month?
📊 Analyzing your question...
🔍 Generate semantic SQL: SELECT SUM(sales_amount) FROM sales_data WHERE region='North' AND sale_date >= '2024-11-01'
✅ Query result: The sales amount in the North last month is ¥1,234,567
```
### 🌐 Multiple Usage Methods
DAT provides multiple usage methods (CLI is mainly used for development and debugging) to meet different scenario needs:
#### 1️⃣ Use through Dify Plugin (WEB End Question)
If you need to conduct intelligent Q&A through the **WEB interface**, you can directly use the DAT plugin on the Dify platform.
🔗 **Plugin address**: [https://marketplace.dify.ai/plugins/hexinfo/dat](https://marketplace.dify.ai/plugins/hexinfo/dat)
First, [start DAT's OpenAPI service](#-dat-server---service-deployment), then install the DAT plugin in Dify and configure `DAT OpenAPI Base URL` to connect with it, and you can create intelligent question applications in Dify's visual interface, providing a friendly WEB interactive experience.
#### 2️⃣ Integrate into Your Project (Streaming Question API)
If you need to integrate the streaming question function into **your WEB project**, you can [start DAT's OpenAPI service](#-dat-server---service-deployment) for docking.
#### 3️⃣ Integrate into Agent (Support MCP Tool)
If you are using an agent that supports **MCP (Model Context Protocol)** (such as Claude Desktop, Cline, etc.), you can [start DAT's MCP service](#-mcp-service) to integrate the intelligent question capability into these agents.
---
## 🛠️ CLI Command Details
### 📖 Command Overview

### 🎯 Core Command
#### 🚀 `dat init` - Project Initialization
```bash
dat init --help
```

**Example usage**:
```bash
# Interactive initialization of DAT project to current working directory
dat init
# Interactive initialization of DAT project to specified project workspace directory
dat init -w ./my-workspace
```

#### 🤖 `dat run` - Intelligent Question
```bash
dat run --help
```

**Example usage**:
```bash
# Current working directory is DAT project directory and start default agent
dat run
# Current working directory is DAT project directory and start specific agent
dat run -a sales-agent
# Specify DAT project directory and start specific agent
dat run -p ./my-project -a sales-agent
```

#### 🌐 `dat server` - Service Deployment
```bash
dat server --help
```

##### 🔌 OpenAPI Service
```bash
dat server openapi --help
```

**Start Service**:
```bash
# Current working directory is DAT project directory
dat server openapi
# Specify DAT project directory
dat server openapi -p ./my-project
# Custom port
dat server openapi --port=9090
```

**Swagger UI Interface**:

**API Call Example**:
```bash
# Streaming question-answering API
curl -X POST http://localhost:8080/api/v1/ask/stream \
-H "Content-Type: application/json" \
-d '{"question": "What is the total number of cases in each country"}' \
--no-buffer
```
##### 🔗 MCP Service
```bash
dat server mcp --help
```

**Start Service**:
```bash
# Current working directory is DAT project directory
dat server mcp
# Specify DAT project directory
dat server mcp -p ./my-project
# Custom port
dat server mcp --port=9091
```

#### 🌱 `dat seed` - Load Seed Data
```bash
dat seed --help
```

**Usage Example**:
```bash
# Current working directory is DAT project directory and load seed CSV file
dat seed
# Specify DAT project directory and load seed CSV file
dat seed -p ./my-project
```

---
## 🏗️ Development Guide
### 📦 Module Architecture
DAT adopts a modular design, with each module having clear responsibilities:
```
dat-parent/
├── ❤️ dat-core/ # Core interfaces and factory management
├── 🔌 dat-adapters/ # Database adapters
│ ├── dat-adapter-duckdb/ # [Local built-in database]
│ ├── dat-adapter-mysql/
│ ├── dat-adapter-oracle/
│ └── dat-adapter-postgresql/
├── 🧠 dat-llms/ # LLM integration module
│ ├── dat-llm-anthropic/
│ ├── dat-llm-gemini/
│ ├── dat-llm-ollama/
│ ├── dat-llm-openai/
│ ├── dat-llm-xinference/
│ └── dat-llm-azure-openai/
├── 📍 dat-embedders/ # Embedding model integration
│ ├── dat-embedder-bge-small-zh/ # [Local built-in Embedding model]
│ ├── dat-embedder-bge-small-zh-q/ # [Local built-in Embedding model]
│ ├── dat-embedder-bge-small-zh-v15/ # [Local built-in Embedding model]
│ ├── dat-embedder-bge-small-zh-v15-q/ # [Local built-in Embedding model]
│ ├── dat-embedder-jina/
│ ├── dat-embedder-ollama/
│ ├── dat-embedder-openai/
│ ├── dat-embedder-xinference/
│ └── dat-embedder-azure-openai/
├── ⚖️ dat-rerankers/ # Re-ranking model integration
│ ├── dat-reranker-onnx-builtin/
│ ├── dat-reranker-ms-marco-minilm-l6-v2/ # [Local built-in Reranking model]
│ ├── dat-reranker-ms-marco-minilm-l6-v2-q/ # [Local built-in Reranking model]
│ ├── dat-reranker-ms-marco-tinybert-l2-v2/ # [Local built-in Reranking model]
│ ├── dat-reranker-ms-marco-tinybert-l2-v2-q/ # [Local built-in Reranking model]
│ ├── dat-reranker-onnx-local/ # [Local call Reranking model]
│ ├── dat-reranker-jina/
│ └── dat-reranker-xinference/
├── 💾 dat-storers/ # Vector storage backends
│ ├── dat-storer-duckdb/ # [Local built-in vector storage]
│ ├── dat-storer-pgvector/
│ ├── dat-storer-weaviate/
│ ├── dat-storer-qdrant/
│ └── dat-storer-milvus/
├── 🤖 dat-agents/ # Intelligent agent implementation
│ └── dat-agent-agentic/
├── 🌐 dat-servers/ # Server-side components
│ ├── dat-server-mcp/
│ └── dat-server-openapi/
├── 📦 dat-sdk/ # Development toolkit
└── 🖥️ dat-cli/ # Command-line tool
```
### 🔧 Local Development Environment
#### Environment Preparation
```bash
# Clone project
git clone https://github.com/hexinfo/dat.git
cd dat
# Install dependencies and compile
mvn clean install -DskipTests
```
### 🚀 Secondary Development Guide
DAT provides the `dat-sdk` development toolkit, which facilitates developers to integrate DAT's intelligent question-answering capabilities into their own Java applications. You can develop custom Web UI, API services, or integrate them into existing systems.
#### Maven Dependency Configuration
Add the following dependency to your project's `pom.xml`:
```xml
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-sdk</artifactId>
<version>0.7.2</version>
</dependency>
```
#### Quick Start Example
```java
import ai.dat.boot.ProjectRunner;
import ai.dat.core.agent.data.StreamAction;
import ai.dat.core.agent.data.StreamEvent;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.Map;
public class DatProjectRunnerExample {
private static final ObjectMapper JSON_MAPPER = new ObjectMapper();
public static void main(String[] args) {
// Initialize project runner
Path projectPath = Paths.get("/path/to/your/dat-project").toAbsolutePath();
String agentName = "default";
Map<String, Object> variables = Collections.emptyMap();
ProjectRunner runner = new ProjectRunner(projectPath, agentName, variables);
// Ask a question
StreamAction action = runner.ask("Total number of medical records by country");
// Handle various stream events
for (StreamEvent event : action) {
System.out.println("-------------------" + event.name() + "-------------------");
event.getIncrementalContent().ifPresent(content -> System.out.println(content));
event.getSemanticSql().ifPresent(content -> System.out.println(content));
event.getQuerySql().ifPresent(content -> System.out.println(content));
event.getQueryData().ifPresent(data -> {
try {
System.out.println(JSON_MAPPER.writeValueAsString(data));
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
});
event.getToolExecutionRequest().ifPresent(request -> System.out.println("id: " + request.id()
+ "\nname: " + request.name() + "\narguments: " + request.arguments()));
event.getToolExecutionResult().ifPresent(result -> System.out.println("result: " + result));
event.getHitlAiRequest().ifPresent(request -> System.out.println(request));
event.getHitlToolApproval().ifPresent(request -> System.out.println(request));
event.getMessages().forEach((k, v) -> {
try {
System.out.println(k + ": " + JSON_MAPPER.writeValueAsString(v));
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
});
}
}
}
```
It is recommended to use high-level classes such as `ai.dat.boot.ProjectRunner`, `ai.dat.boot.ProjectBuilder`, and `ai.dat.boot.ProjectSeeder`.
For more SDK usage examples and best practices, please refer to:
- [Example 1: OpenAPI Server](./dat-servers/dat-server-openapi)
- [Example 2: MCP Server](./dat-servers/dat-server-mcp)
Add required modules as needed:
```xml
<!-- DAT Embedding Store -->
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-storer-duckdb</artifactId> <!-- In-process -->
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-storer-weaviate</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-storer-pgvector</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-storer-qdrant</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-storer-milvus</artifactId>
</dependency>
<!-- DAT Embedding Model -->
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-embedder-bge-small-zh</artifactId> <!-- In-process -->
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-embedder-bge-small-zh-q</artifactId> <!-- In-process -->
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-embedder-bge-small-zh-v15</artifactId> <!-- In-process -->
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-embedder-bge-small-zh-v15-q</artifactId> <!-- In-process -->
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-embedder-onnx-local</artifactId> <!-- In-process -->
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-embedder-openai</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-embedder-ollama</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-embedder-jina</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-embedder-xinference</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-embedder-azure-openai</artifactId>
</dependency>
<!-- DAT Reranking Model -->
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-reranker-ms-marco-minilm-l6-v2</artifactId> <!-- In-process -->
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-reranker-ms-marco-minilm-l6-v2-q</artifactId> <!-- In-process -->
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-reranker-ms-marco-tinybert-l2-v2</artifactId> <!-- In-process -->
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-reranker-ms-marco-tinybert-l2-v2-q</artifactId> <!-- In-process -->
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-reranker-onnx-local</artifactId> <!-- In-process -->
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-reranker-jina</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-reranker-xinference</artifactId>
</dependency>
<!-- DAT Chat Model -->
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-llm-openai</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-llm-anthropic</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-llm-ollama</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-llm-gemini</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-llm-xinference</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-llm-azure-openai</artifactId>
</dependency>
<!-- DAT Database Adapter -->
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-adapter-duckdb</artifactId> <!-- In-process -->
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-adapter-mysql</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-adapter-oracle</artifactId>
</dependency>
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-adapter-postgresql</artifactId>
</dependency>
<!-- DAT Askdata Agent -->
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-agent-agentic</artifactId>
</dependency>
```
You can also develop your own interface class implementation on top of `dat-core`.
```xml
<dependency>
<groupId>cn.hexinfo</groupId>
<artifactId>dat-core</artifactId>
</dependency>
```
---
## Contribution Guide
We welcome all forms of contributions! Whether it's bug reports, feature suggestions, documentation improvements, or code submissions.
### 🐛 Report Issues
Before submitting an issue, make sure:
1. **Search existing issues** - Avoid duplicate submissions
2. **Provide detailed information** - Include error logs, configuration files, and reproduction steps
3. **Use issue templates** - Help us quickly understand the problem
### 💡 Submit Feature Suggestions
We encourage innovative ideas! When submitting feature suggestions, please include:
- **Use case description** - What practical problem does it solve?
- **Design ideas** - Initial implementation thoughts
- **Impact assessment** - Evaluation of the impact on existing features
### 🔧 Code Contribution
#### Development Process
1. **Fork the project** and create a feature branch
```bash
git checkout -b feature/awesome-new-feature
```
2. **Follow code specifications**:
- Use English comments to explain business logic
- Follow Alibaba Java coding specifications
- Keep test coverage > 80%
3. **Submit code**:
```bash
git commit -m "feat: Add ClickHouse database adapter
- Implement ClickHouse connection and query functionality
- Add SQL dialect conversion support
- Improve unit test coverage
- Update relevant documentation
Closes #123"
```
4. **Create a Pull Request**:
- Describe changes in detail
- Associate relevant issues
- Ensure CI checks pass
#### Code Review Standards
- ☑️ **Functional completeness** - Implementation meets requirements
- ☑️ **Code quality** - Follows design patterns and best practices
- ☑️ **Test coverage** - Includes unit tests and integration tests
- ☑️ **Documentation update** - Synchronously update relevant documentation
- ☑️ **Backward compatibility** - Does not break existing APIs
### 🎯 Development Task List
- ✅ Configuration of data models (tables or views);
- ✅ Configuration of semantic models (bound to data models), including: entities, dimensions, metrics, etc.;
- ✅ Generate semantic SQL based on LLM, convert semantic SQL to real SQL, and execute and return data;
- ✅ Intelligent question-answering supports HITL (Human-in-the-Loop) interaction;
- ✅ Support for providing OpenAPI services for intelligent question-answering projects;
- ✅ Support for providing MCP services for intelligent question-answering projects;
- ✅ Support for the seed command to initialize and load CSV files into the database;
- ✅ SQL Q&A pairs, synonyms, business knowledge, and vectorized storage and retrieval;
- ✅ Support for Jinja template language in data models, and data permission control by passing variables through command lines;
- ⬜ Provide DAT project auxiliary development plugins for VSCode, IDEA, Eclipse, and other IDEs;
- ⬜ LLM-based data exploration auxiliary generation of semantic models;
- ⬜ Unit tests for data models, semantic models, and intelligent questions;
- ⬜ Configuration of metrics (can add metrics after building semantic models);
---
## 🌟 Community and Support
### 💬 Communication Channels
- **GitHub Discussions** - Technical discussions and Q&A
- **WeChat group** - Add WeChat `slime_liu` with the note `DAT` to join the community group
### 🏆 Contributor Acknowledgment
Thanks to all developers who have made contributions to the DAT project!
<a href="https://github.com/hexinfo/dat/graphs/contributors">
<img src="https://contrib.rocks/image?repo=hexinfo/dat" />
</a>
---
## 📊 Project Statistics
### ⭐ Star History
[](https://star-history.com/#hexinfo/dat&Date)
---
## 📄 License
This project is licensed under the Apache 2.0 license. See the [LICENSE](https://github.com/hexinfo/dat/blob/main/LICENSE) file for details.
---
<div align="center">
**🎯 Make data queries simple and natural**
**⭐ If this project helps you, give us a Star!**
[🚀 Quick Start](#-quick-start) • [📖 Documentation](https://github.com/hexinfo/dat) • [💬 Join Community](#-community-and-support) • [🤝 Contribute](#-contribution-guide)
---
*Built with ❤️ by the DAT Community*
</div>
Connection Info
You Might Also Like
markitdown
MarkItDown-MCP is a lightweight server for converting URIs to Markdown.
markitdown
Python tool for converting files and office documents to Markdown.
firecrawl
Firecrawl MCP Server enables web scraping, crawling, and content extraction.
Filesystem
Node.js MCP Server for filesystem operations with dynamic access control.
TrendRadar
TrendRadar: Your hotspot assistant for real news in just 30 seconds.
mempalace
The highest-scoring AI memory system ever benchmarked. And it's free.