3gpp MCP Server

The 3GPP MCP Server V3.0.0 provides real-time data services for AI assistants to directly access 3GPP technical specifications through a lightweight API bridging architecture. It integrates the 535-million-word dataset of TSpec-LLM and the official 3GPP API to achieve sub-second structured specification queries.

Research and data Developer tools #3GPP specifications #API bridging #Real-time query #Lightweight architecture .TypeScript

rating : 2 points

downloads : 8.6K

update time : 2025-09-25

Open Site

What is the 3GPP MCP Server?

The 3GPP MCP Server is an intelligent API bridging service that enables your AI assistant to directly access the complete 3GPP technical specification database. It is built based on the Model Context Protocol (MCP) standard and is specifically designed for telecommunications engineers, developers, and researchers.

How to use the 3GPP MCP Server?

With simple configuration commands, your AI assistant can gain the ability to query 3GPP specifications. The server achieves real-time data access through external API integration without the need to store a large number of data files locally.

Use cases

Scenarios that require accurate 3GPP specification information, such as 5G network development, telecommunications standard research, compliance checks, technical specification comparison, and implementation requirement analysis.

Main features

Direct specification search

Directly search 3GPP technical specifications through the TSpec-LLM dataset, providing structured results and relevance scores.

Get specification details

Obtain complete specification metadata, implementation guidance, and dependency analysis.

Multi-specification comparison

Compare multiple 3GPP specifications in parallel, providing evolution analysis and migration impact assessment.

Implementation requirement extraction

Automatically extract technical requirements, test considerations, and compliance requirements from specifications.

External API integration

Integrate the official APIs of Hugging Face and 3GPP.org to ensure data real-time and accuracy.

AI agent optimization

The JSON format response is specifically optimized for AI agent consumption, facilitating automated processing.

Advantages

Lightweight architecture: Only requires 10MB of memory, with a response speed of less than 500ms.

Real-time data access: Obtain the latest 3GPP specification content through the API.

Unlimited scalability: No local storage limitations, supporting concurrent access by multiple users.

Easy integration: Supports all MCP-compatible AI assistants (Claude, VS Code, Cursor, etc.).

Cost-effective: No need to maintain a large local dataset.

Limitations

Requires an internet connection: Depends on external API services.

API limitations: Affected by the rate limits and availability of external services.

Function dependency: Specific functions require an optional Hugging Face token.

Learning curve: Requires basic MCP configuration knowledge.

How to use

Environment preparation

Ensure that Node.js version 18+ and an MCP-compatible AI assistant are installed.

Quick configuration

Complete the MCP server configuration using a one-click command.

Manual configuration (optional)

If you need custom configuration, you can manually edit the MCP configuration file.

Verify installation

Test whether the server is working properly through an example query.

Usage examples

5G charging system development

Query relevant technical specifications and requirements when developing a 5G charging function system.

Specification version migration

Conduct comparative analysis when migrating from an old version of the specification to a new version.

Compliance check

Verify whether the system implementation meets the 3GPP standard requirements.

Frequently Asked Questions

Do I need to download the 15GB 3GPP specification file?

Which AI assistants are supported?

What is the response speed?

Is a Hugging Face token required?

How often is the data updated?

What should I do if I encounter API limitations?

Related resources

Model Context Protocol official website

Official documentation and standard descriptions of the MCP protocol.

TSpec-LLM research paper

The technical research paper that forms the basis of this project's architecture.

3GPP official website

The official website of the 3GPP standards organization.

Node.js download

Download the Node.js runtime environment.

GitHub repository

The open-source code library for the MCP SDK.

🚀 3GPP MCP Server V3.0.0 - Direct Specification Access

Transform your AI assistant into a 3GPP specification expert with direct access to TSpec-LLM's 535M word dataset! This project offers a lightweight API bridge that provides real-time access to 3GPP specifications, enabling structured and agent-ready responses.

🚀 Quick Start

Direct MCP Setup (Recommended)

Claude Desktop users:

claude mcp add 3gpp-server npx 3gpp-mcp-charging@latest serve

For other MCP clients: Add this to your MCP configuration:

{
  "mcpServers": {
    "3gpp-server": {
      "command": "npx",
      "args": ["3gpp-mcp-charging@latest", "serve"],
      "description": "3GPP MCP Server - Direct access to TSpec-LLM and 3GPP specifications",
      "env": {
        "HUGGINGFACE_TOKEN": "optional-for-enhanced-access"
      }
    }
  }
}

Alternative: Auto-Configuration

# One-command installation with auto-configuration
npx 3gpp-mcp-charging@latest init

# Client-specific installation
npx 3gpp-mcp-charging@latest init --client claude
npx 3gpp-mcp-charging@latest init --client vscode
npx 3gpp-mcp-charging@latest init --client cursor

Test It Works

Ask your AI assistant: "Search for 5G CHF implementation requirements in TS 32.290"

You should get structured specification content with implementation guidance, dependencies, and testing considerations!

✨ Features

Revolutionary V3.0.0 Architecture

V3.0.0 represents the True MCP approach - a lightweight API bridge providing direct specification data:

Agent Query → MCP Tools → External APIs → Real Specification Data

Key Benefits:

True MCP Architecture - Lightweight API bridge (~10MB vs 15GB+)
Sub-500ms responses - Intelligent caching with external API integration
Agent-optimized - Structured JSON responses for AI agent consumption
Real specification data - Direct access to TSpec-LLM's 535M word dataset
External API integration - Hugging Face + 3GPP.org APIs
Infinite scalability - Stateless API calls, no local storage limits

💻 Usage Examples

Example Queries

Direct Specification Search:

"Find charging procedures in 5G service-based architecture"
→ Returns: TS 32.290 excerpts, CHF implementation details, Nchf interface specifications

Implementation Requirements:

"Extract implementation requirements for converged charging in Release 17"
→ Returns: Technical requirements, dependencies, testing considerations, compliance notes

Specification Comparison:

"Compare charging evolution from TS 32.240 to TS 32.290"
→ Returns: Evolution timeline, migration analysis, implementation impact assessment

📚 Documentation

Available Tools (V3.0.0)

Tool	Purpose	Input	Output
`search_specifications`	Direct TSpec-LLM search	Query + filters	Structured spec results + relevance scores
`get_specification_details`	Comprehensive spec details	Specification ID	Full metadata + implementation guidance
`compare_specifications`	Multi-spec comparison	Array of spec IDs	Comparison matrix + migration analysis
`find_implementation_requirements`	Requirements extraction	Spec scope + focus	Technical requirements + testing guidance

What You Get

Direct Specification Content

Real-time access to TSpec-LLM's comprehensive 3GPP dataset
Structured content excerpts with relevance scoring
Official specification metadata integration

Agent-Ready Responses

JSON-formatted responses optimized for AI agent consumption
Consistent schema across all tool responses
Rich metadata embedded in all responses

Implementation Intelligence

Technical requirements extraction from specifications
Dependency analysis and implementation guidance
Testing considerations and compliance mapping

Performance Benefits

<500ms cached response times
<2s fresh API call responses
<10MB memory footprint (stateless design)
Unlimited concurrent users (external API scaling)

🔧 Technical Details

Architecture

Core Components

External API Integration Layer

TSpec-LLM Client: Direct integration with TSpec-LLM dataset via Hugging Face APIs
3GPP API Client: Integration with official 3GPP.org APIs for metadata
API Manager: Unified orchestration layer for all external APIs

MCP Tool Layer

search_specifications.ts: Direct specification search implementation
get_specification_details.ts: Comprehensive specification details
compare_specifications.ts: Multi-specification comparison
find_implementation_requirements.ts: Requirements extraction

Caching & Performance

NodeCache: Intelligent API response caching
Rate Limiting: Respectful external API usage
Error Handling: Robust API integration with fallbacks

Project Structure

3gpp-mcp-server-v2/
├── src/                          # V3.0.0 source code
│   ├── api/                      # External API integration layer
│   │   ├── tspec-llm-client.ts   # TSpec-LLM Hugging Face client
│   │   ├── tgpp-api-client.ts    # 3GPP.org official API client
│   │   ├── api-manager.ts        # Unified API orchestration
│   │   └── index.ts              # API exports
│   ├── tools/                    # MCP tool implementations
│   │   ├── search-specifications.ts           # Direct specification search
│   │   ├── get-specification-details.ts       # Comprehensive spec details
│   │   ├── compare-specifications.ts          # Multi-spec comparison
│   │   ├── find-implementation-requirements.ts # Requirements extraction
│   │   └── index.ts              # Tool exports
│   ├── types/                    # TypeScript interfaces
│   └── index.ts                  # MCP server implementation
├── bin/                          # CLI installation tools
├── docs/                         # Documentation
├── tests/                        # Test suite
└── package.json                  # NPM package configuration

Version Evolution

Version	Approach	Storage	Architecture
V1	Data Hosting	15GB+ local dataset	Heavy, non-MCP compliant
V2	Guidance Templates	<100MB knowledge base	Lightweight, guidance-only
V3.0.0	Direct Data Access	<10MB (stateless)	True MCP API bridge

📦 Installation

Requirements

Node.js 18+ - Download from nodejs.org
MCP-compatible AI assistant (Claude Desktop, VS Code, Cursor, or others)
Internet connection - For external API access
Optional: Hugging Face token - For enhanced API access

Installation Options

Option 1: Direct MCP Configuration (Recommended)

No local installation needed! Server runs directly from NPM.

Option 2: Development Setup

# Clone and setup for development
git clone <repository-url>
cd 3gpp-mcp-server/3gpp-mcp-server-v2
npm install
npm run build
npm run start

Option 3: Auto-Configuration

npx 3gpp-mcp-charging@latest init

Environment Variables

# Optional: Enhanced API access
export HUGGINGFACE_TOKEN="your-huggingface-token"

# Optional: Custom cache settings
export CACHE_TIMEOUT="3600"  # seconds
export ENABLE_CACHING="true"

🛠️ Development

Available Scripts

npm run build      # Build TypeScript
npm run dev        # Development with watch
npm run start      # Run the server
npm run test       # Run tests
npm run lint       # Lint code
npm run clean      # Clean build artifacts

Adding New Tools

Create tool class in src/tools/
Define tool schema with input/output types
Implement execute() method with API integration
Export tool and register in src/index.ts

API Integration

Extend TSpecLLMClient for new TSpec-LLM capabilities
Extend TGPPApiClient for additional 3GPP.org endpoints
Add orchestration methods to APIManager

🤝 Contributing

Contributions welcome! Please focus on:

API integration improvements
Performance optimizations
New MCP tool implementations
Documentation enhancements

📄 License

BSD-3-Clause License - see LICENSE file for details.

🙏 Acknowledgments

Research Foundation

This project's V3.0.0 architecture was fundamentally inspired by the TSpec-LLM research:

TSpec-LLM: A Large Language Model for 3GPP Specifications

Paper: https://arxiv.org/abs/2406.01768
Authors: Rasoul Nikbakht, et al.
Dataset: TSpec-LLM on Hugging Face

Originally planned as a document reference MCP, discovery of the TSpec-LLM research paper fundamentally changed our approach. The paper's demonstration of significant accuracy improvements (25+ percentage points) through direct LLM access to 3GPP specifications convinced us to pivot from document hosting to external API integration with their comprehensive 535M word dataset.