Skip to content
Back to search

crawl4ai-mcp-server

πŸ•·οΈ A lightweight Model Context Protocol (MCP) server that exposes Crawl4AI web scraping and crawling capabilities as tools for AI agents. Similar to Firecrawl's API but self-hosted and free. Perfect for integrating web scraping into your AI workflows with OpenAI Agents SDK, Cursor, Claude Code, and other MCP-compatible tools.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/sadiuysal--crawl4ai-mcp-server/badge.svg)](/listings/sadiuysal--crawl4ai-mcp-server)

HTML

<a href="/listings/sadiuysal--crawl4ai-mcp-server"><img src="/api/listings/sadiuysal--crawl4ai-mcp-server/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Choose between **Docker** (recommended) or **manual installation**:

Option A: Docker (Recommended) 🐳

Docker eliminates all setup complexity and provides a consistent environment:

Option A1: Use Pre-built Image (Fastest) ⚑

# No setup required! Just pull and run the published image
docker pull uysalsadi/crawl4ai-mcp-server:latest

# Test it works
python test-config.py

# Use directly in MCP configurations (see examples below)

Option A2: Build Yourself

# Clone the repository
git clone https://github.com/uysalsadi/crawl4ai-mcp-server.git
cd crawl4ai-mcp-server

# Quick build and test (simplified)
docker build -f Dockerfile.simple -t crawl4ai-mcp .
echo '{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "test", "version": "1.0"}}}' | docker run --rm -i crawl4ai-mcp

# Or use helper script (full build with Playwright)
./docker-run.sh build
./docker-run.sh test
./docker-run.sh run

**Docker Quick Commands:** - `./docker-run.sh build` - Build the image - `./docker-run.sh run` - Run MCP server (stdio mode) - `./docker-run.sh test` - Run smoke tests - `./docker-run.sh dev` - Development mode with shell access

Option B: Manual Installation

# Clone and setup
git clone https://github.com/uysalsadi/crawl4ai-mcp-server.git
cd crawl4ai-mcp-server
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
pip install -r requirements.txt

# Install Playwright browsers
python -m playwright install chromium

# Test basic functionality
python -m crawler_agent.smoke_client

# Test adaptive crawling
python test_adaptive.py

Use with OpenAI Agents SDK

# Set your OpenAI API key
export OPENAI_API_KEY="your-key-here"

# Docker: Run the example agent
docker-compose run --rm -e OPENAI_API_KEY crawl4ai-mcp python -m crawler_agent.agents_example

# Manual: Run the example agent
python -m crawler_agent.agents_example

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md Β· README Β· 628 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Crawl4AI MCP Server
  2. πŸ•·οΈ **A lightweight Model Context Protocol (MCP) server that exposes [Crawl4AI](https://docs.crawl4ai.com/) web scraping and crawling capabilities as tools for AI agents.**
  3. Similar to Firecrawl's API but self-hosted and free. Perfect for integrating web scraping into your AI workflows with OpenAI Agents SDK, Cursor, Claude Code, and other MCP-compatible tools.
  4. ## Features
  5. - **πŸ”§ MCP Tools**: Exposes 4 powerful tools: `scrape`, `crawl`, `crawl_site`, `crawl_sitemap` via stdio MCP server
  6. - **🌐 Web Scraping**: Single-page scraping with markdown extraction
  7. - **πŸ•·οΈ Web Crawling**: Multi-page breadth-first crawling with depth control
  8. - **🧠 Adaptive Crawling**: Smart crawling that stops when sufficient content is gathered
  9. - **πŸ›‘οΈ Safety**: Blocks internal networks, localhost, and private IPs
  10. - **πŸ“± Agent Ready**: Works with OpenAI Agents SDK, Cursor, and Claude Code
  11. - **⚑ Fast**: Powered by Playwright and Crawl4AI's optimized extraction
  12. ## πŸš€ Quick Start
  13. Choose between **Docker** (recommended) or **manual installation**:
  14. ### Option A: Docker (Recommended) 🐳
  15. Docker eliminates all setup complexity and provides a consistent environment:
  16. #### Option A1: Use Pre-built Image (Fastest) ⚑
  17. ```bash
  18. # No setup required! Just pull and run the published image
  19. docker pull uysalsadi/crawl4ai-mcp-server:latest
  20. # Test it works
  21. python test-config.py
  22. # Use directly in MCP configurations (see examples below)
  23. ```
  24. #### Option A2: Build Yourself
  25. ```bash
  26. # Clone the repository
  27. git clone https://github.com/uysalsadi/crawl4ai-mcp-server.git
  28. cd crawl4ai-mcp-server
  29. # Quick build and test (simplified)
  30. docker build -f Dockerfile.simple -t crawl4ai-mcp .
  31. echo '{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "test", "version": "1.0"}}}' | docker run --rm -i crawl4ai-mcp
  32. # Or use helper script (full build with Playwright)
  33. ./docker-run.sh build
  34. ./docker-run.sh test
  35. ./docker-run.sh run
  36. ```
  37. **Docker Quick Commands:**
  38. - `./docker-run.sh build` - Build the image
  39. - `./docker-run.sh run` - Run MCP server (stdio mode)
  40. - `./docker-run.sh test` - Run smoke tests
  41. - `./docker-run.sh dev` - Development mode with shell access
  42. ### Option B: Manual Installation
  43. ```bash
  44. # Clone and setup
  45. git clone https://github.com/uysalsadi/crawl4ai-mcp-server.git
  46. cd crawl4ai-mcp-server
  47. python -m venv .venv
  48. source .venv/bin/activate # On Windows: .venv\Scripts\activate
  49. pip install -r requirements.txt
  50. # Install Playwright browsers
  51. python -m playwright install chromium
  52. # Test basic functionality
  53. python -m crawler_agent.smoke_client
  54. # Test adaptive crawling
  55. python test_adaptive.py
  56. ```
  57. ### Use with OpenAI Agents SDK
  58. ```bash
  59. # Set your OpenAI API key
  60. export OPENAI_API_KEY="your-key-here"
  61. # Docker: Run the example agent
  62. docker-compose run --rm -e OPENAI_API_KEY crawl4ai-mcp python -m crawler_agent.agents_example
  63. # Manual: Run the example agent
  64. python -m crawler_agent.agents_example
  65. ```
  66. ## πŸ› οΈ Tools Reference
  67. The MCP server exposes 4 production-ready tools with content hiding features:
  68. ### `scrape`
  69. Fetch a single URL and return markdown content.
  70. **Arguments:**
  71. - `url` (required): The URL to scrape
  72. - `output_dir` (optional): If provided, persists content to disk and returns metadata only
  73. - `crawler`: Optional Crawl4AI crawler config overrides
  74. - `browser`: Optional Crawl4AI browser config overrides
  75. - `script`: Optional C4A-Script for page interaction
  76. - `timeout_sec`: Request timeout (default: 45s, max: 600s)
  77. **Returns (without output_dir):**
  78. ```json
  79. {
  80. "url": "https://example.com",
  81. "markdown": "# Page Title\n\nContent...",
  82. "links": ["https://example.com/page1", "..."],
  83. "metadata": {}
  84. }
  85. ```
  86. **Returns (with output_dir):**
  87. ```json
  88. {
  89. "run_id": "scrape_20250815_122811_4fb188",
  90. "file_path": "/path/to/output/pages/example.com_index.md",
  91. "manifest_path": "/path/to/output/manifest.json",
  92. "bytes_written": 230
  93. }
  94. ```
  95. ### `crawl`
  96. Multi-page breadth-first crawling with filtering and adaptive stopping.
  97. **Arguments:**
  98. - `seed_url` (required): Starting URL for the crawl
  99. - `max_depth`: Maximum link depth to follow (default: 1, max: 4)
  100. - `max_pages`: Maximum pages to crawl (default: 5, max: 100)
  101. - `same_domain_only`: Stay within the same domain (default: true)
  102. - `include_patterns`: Regex patterns URLs must match
  103. - `exclude_patterns`: Regex patterns to exclude URLs
  104. - `adaptive`: Enable adaptive crawling (default: false)
  105. - `output_dir` (optional): If provided, persists content to disk and returns metadata only
  106. - `crawler`, `browser`, `script`, `timeout_sec`: Same as scrape
  107. **Returns (without output_dir):**
  108. ```json
  109. {
  110. "start_url": "https://example.com",
  111. "pages": [
  112. {
  113. "url": "https://example.com/page1",
  114. "markdown": "Content...",
  115. "links": ["..."]
  116. }
  117. ],
  118. "total_pages": 3
  119. }
  120. ```
  121. **Returns (with output_dir):**
  122. ```json
  123. {
  124. "run_id": "crawl_20250815_122828_464944",
  125. "pages_ok": 3,
  126. "pages_failed": 0,
  127. "manifest_path": "/path/to/output/manifest.json",
  128. "bytes_written": 690
  129. }
  130. ```
  131. ### `crawl_site`
  132. Comprehensive site crawling with persistence (always requires output_dir).
  133. **Arguments:**
  134. - `entry_url` (required): Starting URL for site crawl
  135. - `output_dir` (required): Directory to persist results
  136. - `max_depth`: Maximum crawl depth (default: 2, max: 6)
  137. - `max_pages`: Maximum pages to crawl (default: 200, max: 5000)
  138. - Additional config options for filtering and performance
  139. **Returns:**
  140. ```json
  141. {
  142. "run_id": "site_20250815_122851_0e2455",
  143. "output_dir": "/path/to/output",
  144. "manifest_path": "/path/to/output/manifest.json",
  145. "pages_ok": 15,
  146. "pages_failed": 2,
  147. "bytes_written": 45672
  148. }
  149. ```
  150. ### `crawl_sitemap`
  151. Sitemap-based crawling with persistence (always requires output_dir).
  152. **Arguments:**
  153. - `sitemap_url` (required): URL to sitemap.xml
  154. - `output_dir` (required): Directory to persist results
  155. - `max_entries`: Maximum sitemap entries to process (default: 1000)
  156. - Additional config options for filtering and performance
  157. **Returns:**
  158. ```json
  159. {
  160. "run_id": "sitemap_20250815_123006_667d71",
  161. "output_dir": "/path/to/output",
  162. "manifest_path": "/path/to/output/manifest.json",
  163. "pages_ok": 25,
  164. "pages_failed": 0,
  165. "bytes_written": 123456
  166. }
  167. ```
  168. ## πŸ’‘ Usage Examples
  169. ### Standalone MCP Server
  170. ```python
  171. from mcp import ClientSession, StdioServerParameters
  172. from mcp.client.stdio import stdio_client
  173. params = StdioServerParameters(
  174. command="python",
  175. args=["-m", "crawler_agent.mcp_server"]
  176. )
  177. async with stdio_client(params) as (read, write):
  178. async with ClientSession(read, write) as session:
  179. await session.initialize()
  180. # Scrape a single page
  181. result = await session.call_tool("scrape", {
  182. "url": "https://example.com"
  183. })
  184. # Crawl with adaptive stopping
  185. result = await session.call_tool("crawl", {
  186. "seed_url": "https://docs.example.com",
  187. "max_pages": 10,
  188. "adaptive": True
  189. })
  190. ```
  191. ### OpenAI Agents SDK Integration
  192. ```python
  193. from agents import Agent, Runner
  194. from agents.mcp.server import MCPServerStdio
  195. async with MCPServerStdio(
  196. params={
  197. "command": "python",
  198. "args": ["-m", "crawler_agent.mcp_server"]
  199. },
  200. cache_tools_list=True
  201. ) as server:
  202. agent = Agent(
  203. name="Research Assistant",
  204. instructions="Use scrape and crawl tools to research topics.",
  205. mcp_servers=[server],
  206. mcp_config={"convert_schemas_to_strict": True}
  207. )
  208. result = await Runner.run(
  209. agent,
  210. "Research the latest AI safety papers"
  211. )
  212. ```
  213. ### Cursor/Claude Code Integration
  214. This project supports both **Cursor** and **Claude Code** with synchronized configuration:
  215. #### Cursor Setup
  216. - Uses `.cursorrules` for AI assistant behavior and project guidance
  217. - Automatic MCP tool detection and integration
  218. - Project-specific rules and workflow guidance
  219. #### Claude Code Setup
  220. - Uses `CLAUDE.md` for comprehensive project context and memory bank
  221. - Native MCP integration via `mcp__crawl4ai-mcp__*` tool calls
  222. - Global config: `~/.claude/claude_desktop_config.json` or project config: `.mcp.json`
  223. #### Docker Integration for Both Environments
  224. Both Cursor and Claude Code can use the Dockerized MCP server:
  225. ```json
  226. // .mcp.json (project-scoped configuration)
  227. {
  228. "mcpServers": {
  229. "crawl4ai-mcp": {
  230. "command": "docker",
  231. "args": [
  232. "run", "--rm", "-i",
  233. "--volume", "./crawls:/app/crawls",
  234. "uysalsadi/crawl4ai-mcp-server:latest"
  235. ],
  236. "env": {
  237. "CRAWL4AI_MCP_LOG": "INFO"
  238. }
  239. }
  240. }
  241. }
  242. ```
  243. #### Dual Environment Features
  244. - **Synchronized Documentation**: Changes to documentation are maintained across both environments
  245. - **Shared MCP Configuration**: Both use the same MCP server and tool schemas
  246. - **Docker Compatibility**: Consistent environment across both Cursor and Claude Code
  247. - **Cross-Compatible**: Projects work seamlessly whether using Cursor or Claude Code
  248. ## 🐳 Docker Usage
  249. ### Quick Start with Docker
  250. The Docker approach eliminates all manual setup and provides a consistent environment:
  251. ```bash
  252. # 1. Clone and build
  253. git clone https://github.com/uysalsadi/crawl4ai-mcp-server.git
  254. cd crawl4ai-mcp-server
  255. ./docker-run.sh build
  256. # 2. Test the installation
  257. ./docker-run.sh test
  258. # 3. Run MCP server
  259. ./docker-run.sh run
  260. ```
  261. ### Docker Commands Reference
  262. | Command | Description |
  263. |---------|-------------|
  264. | `./docker-run.sh build` | Build the Docker image |
  265. | `./docker-run.sh run` | Run MCP server in stdio mode |
  266. | `./docker-run.sh test` | Run smoke tests |
  267. | `./docker-run.sh dev` | Development mode with shell access |
  268. | `./docker-run.sh stop` | Stop running containers |
  269. | `./docker-run.sh clean` | Remove containers and images |
  270. | `./docker-run.sh logs` | Show container logs |
  271. ### Docker Compose Services
  272. The `docker-compose.yml` provides multiple service configurations:
  273. - **`crawl4ai-mcp`**: Production MCP server
  274. - **`crawl4ai-mcp-dev`**: Development container with shell access
  275. - **`crawl4ai-mcp-test`**: Test runner for smoke tests
  276. ### MCP Integration with Docker
  277. #### Global MCP Configuration (Claude Code)
  278. Add to `~/.claude/claude_desktop_config.json`:
  279. ```json
  280. {
  281. "mcpServers": {
  282. "crawl4ai-mcp": {
  283. "command": "docker",
  284. "args": [
  285. "run", "--rm", "-i",
  286. "--volume", "/tmp/crawl4ai-crawls:/app/crawls",
  287. "uysalsadi/crawl4ai-mcp-server:latest"
  288. ],
  289. "env": {
  290. "CRAWL4AI_MCP_LOG": "INFO"
  291. }
  292. }
  293. }
  294. }
  295. ```
  296. **βœ… Copy this exact config** - it uses the published Docker image!
  297. #### Global MCP Configuration (Cursor)
  298. Add to `~/.cursor/mcp.json`:
  299. ```json
  300. {
  301. "mcpServers": {
  302. "crawl4ai-mcp": {
  303. "command": "docker",
  304. "args": [
  305. "run", "--rm", "-i",
  306. "--volume", "/tmp/crawl4ai-crawls:/app/crawls",
  307. "uysalsadi/crawl4ai-mcp-server:latest"
  308. ],
  309. "env": {
  310. "CRAWL4AI_MCP_LOG": "INFO"
  311. }
  312. }
  313. }
  314. }
  315. ```
  316. **βœ… This configuration is tested and working!**
  317. #### Project-Scoped Configuration
  318. Add to your project's `.mcp.json`:
  319. ```json
  320. {
  321. "mcpServers": {
  322. "crawl4ai-mcp": {
  323. "command": "docker",
  324. "args": [
  325. "run", "--rm", "-i",
  326. "--volume", "./crawls:/app/crawls",
  327. "uysalsadi/crawl4ai-mcp-server:latest"
  328. ],
  329. "env": {
  330. "CRAWL4AI_MCP_LOG": "INFO"
  331. }
  332. }
  333. }
  334. }
  335. ```
  336. **βœ… This project already includes this configuration** - see `.mcp.json`
  337. #### Configuration Validation
  338. After setting up any MCP configuration:
  339. 1. **Test the Docker image works**:
  340. ```bash
  341. python test-config.py
  342. ```
  343. 2. **Restart your editor** (Cursor/Claude Code) to reload MCP configuration
  344. 3. **Verify tools are available**:
  345. - Look for `crawl4ai-mcp` in the MCP tools panel
  346. - Should see 4 tools: `scrape`, `crawl`, `crawl_site`, `crawl_sitemap`
  347. If tools don't appear, check:
  348. - Docker is running and image is accessible
  349. - MCP configuration file syntax is valid JSON
  350. - Editor has been restarted after config changes
  351. ### Docker Advantages
  352. βœ… **Zero Setup**: No need for Python venv, pip, or Playwright installation
  353. βœ… **Consistent Environment**: Same behavior across all platforms
  354. βœ… **Isolated Dependencies**: No conflicts with your system Python
  355. βœ… **Easy Updates**: `docker pull` to get latest version
  356. βœ… **Portable**: Works anywhere Docker runs
  357. βœ… **Volume Persistence**: Crawl outputs saved to host filesystem
  358. ### Environment Variables
  359. Set these when running Docker containers:
  360. ```bash
  361. # Using docker-compose
  362. OPENAI_API_KEY=your-key docker-compose up crawl4ai-mcp
  363. # Using docker run directly
  364. docker run --rm -i \
  365. -e OPENAI_API_KEY=your-key \
  366. -e CRAWL4AI_MCP_LOG=DEBUG \
  367. -v ./crawls:/app/crawls \
  368. crawl4ai-mcp-server:latest
  369. ```
  370. ## βš™οΈ Configuration
  371. ### Environment Variables
  372. - `TARGET_URL`: Default URL for smoke testing (default: https://modelcontextprotocol.io/docs)
  373. - `RESEARCH_TASK`: Custom research task for agents example
  374. - `OPENAI_API_KEY`: Required for OpenAI Agents SDK
  375. ### Safety Settings
  376. The server blocks these URL patterns by default:
  377. - `localhost`, `127.0.0.1`, `::1`
  378. - Private IP ranges (RFC 1918)
  379. - `file://` schemes
  380. - `.local`, `.internal`, `.lan` domains
  381. ## πŸš€ Advanced Features
  382. ### Adaptive Crawling
  383. When `adaptive: true` is set, the crawler uses a simple content-based stopping strategy:
  384. - Stops when total content exceeds 5,000 characters
  385. - Prevents over-crawling for information gathering tasks
  386. - More sophisticated LLM-based strategies can be added
  387. ### Custom Filtering
  388. Use regex patterns to control which URLs are crawled:
  389. ```python
  390. await session.call_tool("crawl", {
  391. "seed_url": "https://docs.example.com",
  392. "include_patterns": [r"/docs/", r"/api/"],
  393. "exclude_patterns": [r"/old/", r"\.pdf$"]
  394. })
  395. ```
  396. ### Browser Configuration
  397. Pass custom browser/crawler settings:
  398. ```python
  399. await session.call_tool("scrape", {
  400. "url": "https://example.com",
  401. "browser": {"headless": True, "viewport": {"width": 1280, "height": 720}},
  402. "crawler": {"verbose": True}
  403. })
  404. ```
  405. ## πŸ—οΈ Architecture
  406. ```
  407. β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”
  408. β”‚ AI Agent │───▢│ MCP Server │───▢│ Crawl4AI β”‚
  409. β”‚ (Cursor/Agents) β”‚ β”‚ (stdio/stdio) β”‚ β”‚ (Playwright) β”‚
  410. β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜
  411. β”‚
  412. β–Ό
  413. β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”
  414. β”‚ Safety Guards β”‚
  415. β”‚ (URL validation) β”‚
  416. β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜
  417. ```
  418. ## πŸ“¦ Publishing to Docker Hub
  419. For maintainers who want to publish updates to the Docker registry:
  420. ### Publishing Process
  421. ```bash
  422. # 1. Login to Docker Hub (one time setup)
  423. ./docker-push.sh login
  424. # 2. Build, push, and test everything
  425. ./docker-push.sh all
  426. # Or do steps individually:
  427. ./docker-push.sh build # Build and tag image
  428. ./docker-push.sh push # Push to Docker Hub
  429. ./docker-push.sh test # Test the published image
  430. ```
  431. ### Docker Hub Repository
  432. The image is published at: **`uysalsadi/crawl4ai-mcp-server`**
  433. - Latest: `uysalsadi/crawl4ai-mcp-server:latest`
  434. - Versioned: `uysalsadi/crawl4ai-mcp-server:v1.0.0`
  435. ### Usage Statistics
  436. Users can pull and use the image without any local setup:
  437. ```bash
  438. docker pull uysalsadi/crawl4ai-mcp-server:latest
  439. ```
  440. ## πŸ”§ Development
  441. ### Project Structure
  442. ```
  443. crawler_agent/
  444. β”œβ”€β”€ __init__.py
  445. β”œβ”€β”€ mcp_server.py # Main MCP server
  446. β”œβ”€β”€ safety.py # URL safety validation
  447. β”œβ”€β”€ adaptive_strategy.py # Adaptive crawling logic
  448. β”œβ”€β”€ smoke_client.py # Basic testing client
  449. └── agents_example.py # OpenAI Agents SDK example
  450. ```
  451. ### Testing
  452. ```bash
  453. # Test MCP server
  454. python -m crawler_agent.smoke_client
  455. # Test adaptive crawling
  456. python test_adaptive.py
  457. # Test with agents (requires OPENAI_API_KEY)
  458. python -m crawler_agent.agents_example
  459. ```
  460. ### Contributing
  461. 1. **Environment Setup**: Always activate `.venv` before development work
  462. 2. **Documentation**: Follow the Documentation Memory Rule - synchronize changes across CLAUDE.md, .cursorrules, and README.md
  463. 3. **Code Style**: Follow `.cursorrules` for Cursor or `CLAUDE.md` for Claude Code
  464. 4. **Testing**: Use `python -m crawler_agent.smoke_client` for validation
  465. 5. **Safety**: Ensure security guards are maintained for all new features
  466. 6. **Dual Compatibility**: Verify changes work in both Cursor and Claude Code environments
  467. ## πŸ“š References
  468. - [Crawl4AI Documentation](https://docs.crawl4ai.com/)
  469. - [Model Context Protocol](https://modelcontextprotocol.io/introduction)
  470. - [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/mcp/)
  471. - [MCP Tools Reference](https://openai.github.io/openai-agents-python/tools/)
  472. ## πŸ“„ License
  473. MIT License - see [LICENSE](LICENSE) file for details.
  474. ### πŸ™ Acknowledgments
  475. This project uses [Crawl4AI](https://github.com/unclecode/crawl4ai) by [UncleCode](https://github.com/unclecode) for web scraping capabilities. Crawl4AI is an excellent open-source LLM-friendly web crawler and scraper.
  476. ## 🀝 Contributing
  477. Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
  478. ## ⭐ Support
  479. If this project helped you, please give it a star! It helps others discover the project.
  480. ## πŸ› Issues
  481. Found a bug or have a feature request? Please [open an issue](https://github.com/uysalsadi/crawl4ai-mcp-server/issues).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.