Skip to main content
Glama
deenesjakoruzh

MCP-Smallest.ai

by VinayakTiwari1103
GitHub
TypeScript
3
OverviewInspectNewEndpointsSchemaRelated ServersReviewsScore
Need Help?View Source CodeReport Issue

image

MCP-Smallest.ai

A Model Context Protocol (MCP) server implementation for Smallest.ai API integration. This project provides a standardized interface for interacting with Smallest.ai's knowledge base management system.

Architecture

System Overview

Untitled-2025-03-21-0340(6)

┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ │ │ │ │ │ │ Client App │◄────┤ MCP Server │◄────┤ Smallest.ai │ │ │ │ │ │ API │ └─────────────────┘ └─────────────────┘ └─────────────────┘

Component Details

1. Client Application Layer
  • Implements MCP client protocol
  • Handles request formatting
  • Manages response parsing
  • Provides error handling
2. MCP Server Layer
  • Protocol Handler
    • Manages MCP protocol communication
    • Handles client connections
    • Routes requests to appropriate tools
  • Tool Implementation
    • Knowledge base management tools
    • Parameter validation
    • Response formatting
    • Error handling
  • API Integration
    • Smallest.ai API communication
    • Authentication management
    • Request/response handling
3. Smallest.ai API Layer
  • Knowledge base management
  • Data storage and retrieval
  • Authentication and authorization

Data Flow

1. Client Request └─► MCP Protocol Validation └─► Tool Parameter Validation └─► API Request Formation └─► Smallest.ai API Call └─► Response Processing └─► Client Response

Security Architecture

┌─────────────────┐ │ Client Auth │ └────────┬────────┘ │ ┌────────▼────────┐ │ MCP Validation │ └────────┬────────┘ │ ┌────────▼────────┐ │ API Auth │ └────────┬────────┘ │ ┌────────▼────────┐ │ Smallest.ai │ └─────────────────┘

Overview

This project implements an MCP server that acts as a middleware between clients and the Smallest.ai API. It provides a standardized way to interact with Smallest.ai's knowledge base management features through the Model Context Protocol.

Architecture

[Client Application] <---> [MCP Server] <---> [Smallest.ai API]

Components

  1. MCP Server
    • Handles client requests
    • Manages API communication
    • Provides standardized responses
    • Implements error handling
  2. Knowledge Base Tools
    • listKnowledgeBases: Lists all knowledge bases
    • createKnowledgeBase: Creates new knowledge bases
    • getKnowledgeBase: Retrieves specific knowledge base details
  3. Documentation Resource
    • Available at docs://smallest.ai
    • Provides usage instructions and examples

Prerequisites

  • Node.js 18+ or Bun runtime
  • Smallest.ai API key
  • TypeScript knowledge

Installation

  1. Clone the repository:
git clone https://github.com/yourusername/MCP-smallest.ai.git cd MCP-smallest.ai
  1. Install dependencies:
bun install
  1. Create a .env file in the root directory:
SMALLEST_AI_API_KEY=your_api_key_here

Configuration

Create a config.ts file with your Smallest.ai API configuration:

export const config = { API_KEY: process.env.SMALLEST_AI_API_KEY, BASE_URL: 'https://atoms-api.smallest.ai/api/v1' };

Usage

Starting the Server

bun run index.ts

Testing the Server

bun run test-client.ts

Available Tools

  1. List Knowledge Bases
await client.callTool({ name: "listKnowledgeBases", arguments: {} });
  1. Create Knowledge Base
await client.callTool({ name: "createKnowledgeBase", arguments: { name: "My Knowledge Base", description: "Description of the knowledge base" } });
  1. Get Knowledge Base
await client.callTool({ name: "getKnowledgeBase", arguments: { id: "knowledge_base_id" } });

Response Format

All responses follow this structure:

{ content: [{ type: "text", text: JSON.stringify(data, null, 2) }] }

Error Handling

The server implements comprehensive error handling:

  • HTTP errors
  • API errors
  • Parameter validation errors
  • Type-safe error responses

Development

Project Structure

MCP-smallest.ai/ ├── index.ts # MCP server implementation ├── test-client.ts # Test client implementation ├── config.ts # Configuration file ├── package.json # Project dependencies ├── tsconfig.json # TypeScript configuration └── README.md # This file

Adding New Tools

  1. Define the tool in index.ts:
server.tool( "toolName", { param1: z.string(), param2: z.number() }, async (args) => { // Implementation } );
  1. Update documentation in the resource:
server.resource( "documentation", "docs://smallest.ai", async (uri) => ({ contents: [{ uri: uri.href, text: `Updated documentation...` }] }) );

Security

  • API keys are stored in environment variables
  • All requests are authenticated
  • Parameter validation is implemented
  • Error messages are sanitized

Contributing

  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

Install Server
A
security – no known vulnerabilities
F
license - not found
A
quality - confirmed to work

How are these scores calculated?

remote-capable server

The server can be hosted and run remotely because it primarily relies on remote services or has no dependency on the local environment.

Tools

A Model Context Protocol server implementation that provides a standardized interface for interacting with Smallest.ai's knowledge base management system.

  1. Architecture
    1. System Overview
    2. Component Details
    3. Data Flow
    4. Security Architecture
  2. Overview
    1. Architecture
      1. Components
    2. Prerequisites
      1. Installation
        1. Configuration
          1. Usage
            1. Starting the Server
            2. Testing the Server
            3. Available Tools
          2. Response Format
            1. Error Handling
              1. Development
                1. Project Structure
                2. Adding New Tools
              2. Security
                1. Contributing
                  1. License
                    1. Acknowledgments

                      Related MCP Servers

                      • MCP Toolkit

                        zxfgds
                        -
                        security
                        F
                        license
                        -
                        quality
                        A comprehensive Model Context Protocol server implementation that enables AI assistants to interact with file systems, databases, GitHub repositories, web resources, and system tools while maintaining security and control.
                        Last updated -
                        3
                        1
                        TypeScript

                      • MCP Boilerplate

                        iamsrikanthnani
                        -
                        security
                        A
                        license
                        -
                        quality
                        A server that implements the Model Context Protocol, providing a standardized way to connect AI models to different data sources and tools.
                        Last updated -
                        2
                        8
                        TypeScript
                        MIT License

                      • MCP AI Chat LangChain

                        badrinathvm
                        -
                        security
                        F
                        license
                        -
                        quality
                        A basic Model Context Protocol server implementation that demonstrates core functionality including tools and resources for AI chat applications.
                        Last updated -
                        Python

                      • RL-MCP

                        rlefko
                        -
                        security
                        F
                        license
                        -
                        quality
                        A Model Context Protocol server that provides AI models with structured access to external data and services, acting as a bridge between AI assistants and applications, databases, and APIs in a standardized, secure way.
                        Last updated -
                        2
                        Python

                      View all related MCP servers

                      MCP directory API

                      We provide all the information about MCP servers via our MCP API.

                      curl -X GET 'https://glama.ai/api/mcp/v1/servers/VinayakTiwari1103/MCP-smallest-ai'

                      If you have feedback or need assistance with the MCP directory API, please join our Discord server