Iamkrmayank MCP

MCP浏览器工具

提供方 Iamkrmayank

浏览器工具 stdio · 本地进程 无需鉴权 社区 / 第三方
查看接入方式

Agno MCP编排系统是一个基于模型上下文协议(MCP)的网页数据抓取框架,具有自动回退机制和全面的日志记录功能,适用于需要高效、可靠数据提取的场景。

一句话选型结论

按资料字段整理

Iamkrmayank MCP 属于浏览器工具类 MCP 服务器,stdio · 本地进程,无需鉴权,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类浏览器工具 传输方式stdio · 本地进程 鉴权无需鉴权 部署方式本地部署
GitHub 星标 0 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

浏览器工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

适用场景

网页抓取Python本地部署数据提取自动回退日志记录自然语言查询

安装与配置

stdio · 本地进程 无需鉴权
客户端在本机拉起子进程,数据不出本机
pip install -r requirements.txt

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
自动操作网页

打开页面、点击、填表,把浏览器动作交给模型执行。

抓取结构化数据

把页面内容整理成表格或 JSON,省掉手工复制粘贴。

关键流程回归

按步骤检查页面是否正常,回归时少漏环节。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 资料标注无需鉴权,装好就能连。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在浏览器工具场景里让模型直接调用外部能力的人。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Iamkrmayank MCP当前 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Playwright MCP Server 21 stdio · 本地进程 本地部署 有 2026-05-18
Fetch 9a2682de 1 SSE · 服务端推送 支持远程部署 有 2026-05-18
Browser 738d52bc 未标注 stdio · 本地进程 本地部署 有 2026-05-17
MCP 40600ece 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Skyvern MCP 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

浏览器工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方Iamkrmayank上游标注的维护方 Iamkrmayank
分类浏览器工具本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式无需鉴权远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验2026-05-17上游最后核验时间

详细介绍

10.9 KB
来自项目仓库与上游目录的原文,未做删改

Agno MCP Orchestration System

A comprehensive web scraping orchestration framework with automatic fallback mechanisms, built on the Model Context Protocol (MCP).

🎯 System Overview

The Agno orchestration system provides a robust, production-ready solution for web data extraction with:

  • Multi-source scraping with intelligent fallback
  • Comprehensive logging with timestamps and performance metrics
  • MCP integration for seamless tool coordination
  • Natural language queries with automatic preprocessing
  • Transparent feedback on execution status

Architecture```

User Input
↓
Agno Orchestrator (preprocesses & coordinates)
↓
MCP Tools Framework (manages execution)
↓
Primary: Tavily API (fast, structured extraction)
↓ (on failure)
Fallback: Jina API (semantic understanding)
↓
Formatted Response + Execution Logs


## 🚀 Quick Start

### Prerequisites

- Python 3.10 or higher
- API keys for:
  - Tavily (primary scraping)
  - Jina (fallback scraping, optional)

### Installation

1. Clone the repository:```bash
git clone https://github.com/yourusername/mcp-server.git
cd mcp-server
  1. Install dependencies:```bash
    pip install -r requirements.txt

3. Configure environment variables:```bash
# Copy example environment file
cp .env.example .env

# Edit .env with your API keys
# Required:
TAVILY_API_KEY=your_tavily_api_key_here

# Optional:
JINA_API_KEY=your_jina_api_key_here

# Configuration (optional):
LOG_LEVEL=INFO
LOG_FILE=agno_system.log
MAX_RETRIES=3
TIMEOUT_SECONDS=30

Usage

As MCP Server

Run as an MCP server (for integration with MCP-compatible clients):```bash
python -m src.server


#### As CLI Tool

Run standalone queries from the command line:```bash
# Basic usage
python -m src.cli "Tell me about Microsoft 2024 report"

# With custom formatting
python -m src.cli "What happened in AI in 2024?" --format markdown

# With more results
python -m src.cli "Latest climate change news" --max-results 10

# Show statistics
python -m src.cli "Search query" --stats

Programmatic Usage```python

import asyncio
from src.agno_orchestrator import AgnoOrchestrator

async def main():
# Initialize orchestrator
orchestrator = AgnoOrchestrator()

# Process a request
response = await orchestrator.process_request(
    user_input="Tell me about Microsoft 2024 report",
    max_results=5
)

# Format and display
if response.success:
    formatted = orchestrator.format_response(response, format_type="markdown")
    print(formatted)
else:
    print(f"Error: {response.error}")

asyncio.run(main())


## 📋 Core Components

### 1. Agno Orchestrator (`src/agno_orchestrator.py`)

Central control layer that:
- Preprocesses natural language queries
- Coordinates tool execution with priority-based selection
- Manages automatic fallback mechanisms
- Provides transparent user feedback
- Tracks system statistics

**Key Methods:**
- `process_request(user_input, **kwargs)` - Main entry point for queries
- `format_response(response, format_type)` - Format results as structured/JSON/Markdown
- `get_statistics()` - Retrieve system performance metrics

### 2. MCP Tools Framework (`src/mcp_tools_integration.py`)

Unified interface for tool management:
- Dynamic tool registration and discovery
- Priority-based execution ordering
- Result validation with confidence scoring
- Execution history tracking
- Automatic failover handling

**Key Classes:**
- `BaseTool` - Abstract base for all scraping tools
- `ToolRegistry` - Central registry for tool management
- `MCPToolsFramework` - Main coordination framework
- `ToolResult` - Standardized result container

### 3. Scraping Tools

#### Tavily Tool (`src/tools/tavily_tool.py`)
- **Priority:** 0 (highest)
- **Purpose:** Fast, structured web extraction
- **Features:**
  - Configurable search depth (basic/advanced)
  - Domain filtering (include/exclude)
  - Automatic confidence calculation
  - Rich result metadata

#### Jina Tool (`src/tools/jina_tool.py`)
- **Priority:** 1 (fallback)
- **Purpose:** Semantic web understanding
- **Features:**
  - Search API integration
  - Reader API for content extraction
  - Fallback search mechanisms
  - Works without API key (rate-limited)

### 4. Logging System (`src/logging_system.py`)

Comprehensive logging with:
- UTC timestamps on all events
- Operation-level tracking (start/end)
- Duration measurements (milliseconds)
- Success/failure status
- Data quality metrics (confidence, completeness)
- Fallback event logging

**Log Format:**```
2024-10-14 15:30:45 UTC - AgnoSystem - INFO - [Tavily_Request] Status: success | Duration: 1250.45ms | Quality: {"confidence": 0.85}

5. Configuration Management (src/config.py)

Centralized configuration:
- Environment variable loading
- Configuration validation
- Default value management
- Secure API key handling

🔧 Configuration Options

Variable Description Default Required
TAVILY_API_KEY Tavily API key - Yes*
JINA_API_KEY Jina API key - No
LOG_LEVEL Logging level INFO No
LOG_FILE Log file path agno_system.log No
TIMEOUT_SECONDS Request timeout 30 No
MAX_RETRIES Max retry attempts 3 No
MIN_CONFIDENCE Min confidence threshold 0.5 No

*At least one API key (Tavily or Jina) must be configured.

📊 System Features

Priority-Based Execution

Tools are executed in priority order:
1. Tavily (priority 0) - Primary fast extraction
2. Jina (priority 1) - Semantic fallback

On failure or low confidence, the system automatically tries the next tool.

Automatic Fallback```python

Fallback triggers when:

  1. Primary tool fails (error, timeout)
  2. Result confidence below threshold
  3. Empty or invalid data returned

Fallback is logged:

{
"timestamp": "2024-10-14T15:30:45.123Z",
"operation": "Fallback_Triggered",
"from": "Tavily",
"to": "Jina",
"reason": "Tavily request timeout"
}


### Confidence Scoring

Each result includes a confidence score (0.0-1.0) based on:
- Number of results found
- Quality scores from source
- Presence of summary answer
- Content completeness

### Transparent Feedback

Users receive clear status messages:
- ✓ **Success:** "Results retrieved successfully from Tavily."
- ✓ **Fallback Used:** "Primary source unavailable, fallback mechanism used."
- ⚠ **Timeout:** "Request timed out. Please try again."
- ✗ **Failure:** "Unable to retrieve results. All sources failed."

## 📝 Logging Standards

Every operation logs:
1. **Timestamp** - UTC ISO format
2. **Operation Name** - e.g., "Tavily_Request"
3. **Duration** - Execution time in milliseconds
4. **Status** - success/failure/timeout/in_progress
5. **Error Message** - If applicable
6. **Data Quality** - Confidence and completeness metrics
7. **Metadata** - Additional context

Example log entry:```json
{
  "timestamp": "2024-10-14T15:30:45.123456Z",
  "operation": "Tavily_Request_End",
  "status": "success",
  "duration_ms": 1250.45,
  "error": null,
  "data_quality": {
    "confidence": 0.85
  },
  "metadata": {
    "result_count": 5,
    "search_depth": "basic"
  }
}

🛠️ Development

Project Structure```

mcp-server/
├── src/
│ ├── init.py
│ ├── server.py # MCP server entry point
│ ├── cli.py # Command-line interface
│ ├── config.py # Configuration management
│ ├── logging_system.py # Comprehensive logging
│ ├── agno_orchestrator.py # Main orchestration logic
│ ├── mcp_tools_integration.py # Tool framework
│ └── tools/
│ ├── init.py
│ ├── tavily_tool.py # Tavily integration
│ └── jina_tool.py # Jina integration
├── requirements.txt # Python dependencies
├── .env.example # Example environment file
├── .gitignore # Git ignore rules
└── README.md # This file


### Adding New Tools

1. Create a new tool class inheriting from `BaseTool`:```python
from src.mcp_tools_integration import BaseTool, ToolResult, ToolStatus

class MyCustomTool(BaseTool):
    def __init__(self, api_key=None):
        super().__init__(name="MyTool", priority=2)  # Lower priority = fallback
        self.api_key = api_key

    def is_available(self) -> bool:
        return bool(self.api_key)

    async def execute(self, query: str, **kwargs) -> ToolResult:
        # Implement your scraping logic
        try:
            # ... scraping code ...
            return ToolResult(
                status=ToolStatus.SUCCESS,
                data={"results": []},
                confidence=0.8
            )
        except Exception as e:
            return ToolResult(
                status=ToolStatus.FAILURE,
                error=str(e)
            )
  1. Register the tool in the orchestrator:```python
    from src.tools.my_custom_tool import MyCustomTool

In AgnoOrchestrator._register_tools()

custom_tool = MyCustomTool(api_key=custom_api_key)
self.framework.register_tool(custom_tool)


### Running Tests```bash
# Test CLI
python -m src.cli "test query" --format json

# Test specific queries
python -m src.cli "Microsoft 2024 report" --stats
python -m src.cli "Latest AI news" --max-results 10 --format markdown

📈 System Statistics

Track system performance:```python
stats = orchestrator.get_statistics()

Returns:

{
"total_requests": 100,
"successful_requests": 95,
"success_rate": 95.0,
"fallback_count": 12,
"fallback_rate": 12.0,
"available_tools": 2,
"registered_tools": 2
}
```

🔒 Security

  • API keys stored in environment variables
  • Keys never logged or exposed in output
  • HTTPS for all API communications
  • No sensitive data stored in logs

🐛 Troubleshooting

"No scraping tools are available"

  • Check that at least one API key is configured in .env
  • Verify API keys are valid

"Request timed out"

  • Increase TIMEOUT_SECONDS in .env
  • Check internet connection
  • Verify API services are operational

"All tools failed"

  • Check API key validity
  • Review logs in agno_system.log
  • Ensure query is well-formed
  • Try with different queries

Low confidence results

  • Adjust MIN_CONFIDENCE threshold
  • Use more specific queries
  • Try with search_depth=advanced for Tavily

📄 License

MIT License - See LICENSE file for details

🤝 Contributing

Contributions welcome! Please:
1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests if applicable
5. Submit a pull request

📞 Support

For issues, questions, or feature requests:
- Open an issue on GitHub
- Check existing issues for solutions
- Review logs for debugging information

🎉 Acknowledgments

Built with:
- MCP (Model Context Protocol)
- Tavily API
- Jina AI
- Python asyncio and httpx


Version: 1.0.0
Last Updated: October 2025

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
Iamkrmayank MCP 怎么安装?

在客户端按下面的安装命令接入:pip install -r requirements.txt。装完在客户端配置里引用同一个包或端点。

Iamkrmayank MCP 怎么在客户端里配置?

它的传输方式未标注,在客户端 MCP 配置里按官方文档填写启动命令和参数,保存后重启客户端生效。

Iamkrmayank MCP 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Iamkrmayank MCP 需要 API Key 吗?

资料标注为无需认证,装好就能连;如果实际调用时报鉴权错误,按官方文档补上凭据。

Iamkrmayank MCP 能提供哪些能力?

资料显示能力标签包括 浏览器自动化、日志记录、Python、数据提取。具体工具清单以官方文档为准。

Iamkrmayank MCP 需要什么运行环境?

属于本地进程,需要在本机装好运行环境。

Iamkrmayank MCP 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-05-17。