SMCP Proxy (OIDC)

🚀 SMCP Proxy Guide

SMCP Proxy is a middleware that supports multiple model service protocols, allowing users to access different backend services through a unified interface.

🚀 Quick Start

SMCP Proxy enables users to access various backend services via a unified interface. Below is a basic usage example:

Example Configuration (proxy-server.yml)

global:
  port: 8080
  host: "localhost"
  log_level: "info"
  enable_metrics: true

backends:
  mcp-sequential:
    url: "http://localhost:3001/api"
    strip_path: "/v1/sequentialthinking"

  mcp-memory:
    command: "docker"
    args:
      - run
      - --rm
      - -i
      - mcr.microsoft.com/hugginginception/transformers Glenn Glock/llama2-70b-instruct

📦 Installation

Install from Source Code

1. Clone the repository:

git clone git@github.com:yourusername/smc-proxy.git
cd smc-proxy

2. Download dependencies and build:

go mod tidy
go build -o bin/smc cmd/sm/main.go

3. Install to the system directory (optional):

sudo cp bin/smc /usr/local/bin/

Install from Binary

Download the pre - compiled binary and choose the appropriate version according to your operating system.

📚 Documentation

Global Configuration

Backend Configuration

Two types of backends are supported:

1. HTTP Type:

backend_name:
  transport: "http"
  url: "http://example.com/mcp"

2. Stdio Type:

backend_name:
  transport: "stdio"
  command: "docker"
  args:
    - run
    - --rm
    - -i
    - your/image:tag

💻 Usage Examples

Basic Usage

POST /api/prompt HTTP/1.1
Content-Type: application/json

{
  "model": "gpt-3.5-turbo",
  "messages": [
    {
      "role": "user",
      "content": "你好！"
    }
  ]
}

Return Format

HTTP/1.1 200 OK
Content-Type: application/json

{
  "id": "chatcmpl-XXXXX",
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "你好！很高兴见到你。"
      }
    }
  ]
}

Scenario 1: Access Multiple Backends via a Unified Interface

curl http://localhost:8080/api/prompt \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-3.5-turbo", "messages":[{"role":"user","content":"你好！"}]}'

Scenario 2: Integrate into an Existing System

package main

import (
    "net/http"
)

func main() {
    http.ListenAndServe(":8081", smc.NewRouter())
}

🔧 Technical Details

Project Structure

smc-proxy/
├── cmd/
│   └── sm/                # Main program entry
│       ├── main.go        # Entry file
│       └── config.go      # Configuration loading logic
├── internal/
│   ├── middleware/       # Middleware implementation
│   │   ├── log.go        # Logging middleware
│   │   └── recovery.go   # Error recovery middleware
├── go.mod                # Dependency management file
└── go.sum                # Dependency verification file

Design Principles

1. High Availability: Supports load balancing and failover.
2. Scalability: Facilitates the addition of new backend services.
3. High Performance: Optimizes request processing through middleware.

⚠️ Important Note

1. Performance Tuning:
   • Use Golang's sync.Pool to optimize memory usage.
   • Avoid performing blocking operations in middleware.
2. Log Management:
   • Set different log levels according to the environment.
   • Regularly clean up old log files.
3. Security Measures:
   • Enable HTTPS to ensure secure data transmission.
   • Configure CORS policies to control cross - origin access.

📄 License

This project is licensed under the MIT License.

🤝 Contribution Guide

1. Run go fmt ./... and go test ./... before submitting code.
2. Submit a pull request on GitHub.
3. Submit documentation updates.