Cloud MCP SSE setup guide

Ai4Scholar-MCP provides academic search across multiple sources through a cloud service. Once configured, you can search papers and look up paper details and citation information in an AI conversation, without deploying an MCP server yourself.

Before you connect

1. Sign in to Ai4Scholar and create or copy your key in API key management.
2. Choose an MCP client that supports remote SSE and custom request headers.
3. Follow the steps for your client below. After saving, enable the tools and test a search.

Every YOUR_API_KEY in this guide is a placeholder. Replace it with your own Ai4Scholar API key. Keep the Bearer prefix, including its trailing space. Enter the key in the client's MCP configuration; do not send it in a conversation or commit it to a public repository.

Connection details

If the client separates headers into Name and Value fields, enter the two values above separately. For a single-line input, follow the client's format. For example, Cherry Studio uses Authorization=Bearer YOUR_API_KEY.

SSE and Streamable HTTP are different MCP transports. If the client offers an explicit transport setting, choose SSE for this URL. Clients with only an HTTP option must support SSE fallback to use this endpoint.

Choose your client

Click a client name to jump to its instructions. Configuration formats differ, so use the example for your own client.

Cherry Studio

1. Open Settings → MCP Servers → Add Server.
2. Enter ai4scholar as the name. You can use "Ai4Scholar academic search" as the description.
3. Select Server-Sent Events (SSE) as the type and enter https://mcp.ai4scholar.net/sse as the URL.
4. Enter the following line in the headers field, replacing the API key.

Authorization=Bearer YOUR_API_KEY

5. Save and turn on the server's enable switch. Wait for the tool list to load.
6. Return to the conversation, choose "Manual" in the input box's MCP menu, select ai4scholar, and send a search request. In the newer Agent interface, enable the server under Work → Agent menu → Edit → MCP.

After saving the server, you must also enable it in the current conversation or Agent. If no tool calls appear, check both switches. See the Cherry Studio MCP documentation for the newer interface.

Cursor

Open Cursor's MCP settings, or edit .cursor/mcp.json in your project. To make the service available in all projects, edit ~/.cursor/mcp.json.

{
  "mcpServers": {
    "ai4scholar": {
      "url": "https://mcp.ai4scholar.net/sse",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

If the file already contains other services, merge only the ai4scholar entry into the existing mcpServers object alongside them, keeping the original configuration.

After saving, return to MCP settings and confirm that the service is enabled and its tools are loaded. Then search from an Agent conversation. See the Cursor MCP documentation for configuration locations and fields.

Claude Code

Run this command in a terminal to add the cloud service to your user configuration for use across projects:

claude mcp add --transport sse --scope user ai4scholar https://mcp.ai4scholar.net/sse --header "Authorization: Bearer YOUR_API_KEY"

After adding it, enter /mcp in a Claude Code conversation to check the connection status and tool list for ai4scholar. To use it only in the current project, omit --scope user.

The official Claude Code documentation explains SSE and custom request headers. If the connection fails, update the client and check the headers first, then follow the FAQ at the end of this guide.

Chatbox

Open MCP management in settings and add a remote server. Use ai4scholar as the name and https://mcp.ai4scholar.net/sse as the service URL. Add an Authorization header with the value Bearer YOUR_API_KEY.

If your version supports JSON import, use:

{
  "mcpServers": {
    "ai4scholar": {
      "url": "https://mcp.ai4scholar.net/sse",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Click "Test" to verify connectivity. Once successful, save and enable the service, then use it in a work mode that supports tool calls. Menus may vary by version; see Chatbox work mode configuration.

Dify

1. Open Tools → MCP in your workspace and add an MCP server. In some versions, the entry is named "Add MCP Server (HTTP)".
2. Enter ai4scholar as the name and https://mcp.ai4scholar.net/sse as the Server URL.
3. Under Headers, add Authorization with the value Bearer YOUR_API_KEY. If a transport option is shown, choose SSE.
4. Save, complete connection verification, and confirm that the tool list has loaded.
5. Select the new MCP tool in a Workflow or Agent, set a search query, and run a test.

If your version has no MCP entry point, or it cannot send custom headers or connect through SSE, use the Ai4Scholar Dify plugin.

Kimi Code

Enter /mcp-config in Kimi Code to manage servers, or edit the MCP configuration file. The current official documentation lists ~/.kimi-code/mcp.json for user configuration and .kimi-code/mcp.json for project configuration. Older versions may use different paths.

{
  "mcpServers": {
    "ai4scholar": {
      "transport": "sse",
      "url": "https://mcp.ai4scholar.net/sse",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

You must explicitly set "transport": "sse". After saving, start a new session and enter /mcp to check the connection. See the Kimi Code MCP documentation for the configuration format and version differences.

Gemini CLI

Add the service in a terminal:

gemini mcp add --transport sse --scope user ai4scholar https://mcp.ai4scholar.net/sse --header "Authorization: Bearer YOUR_API_KEY"

Alternatively, edit ~/.gemini/settings.json or your project's .gemini/settings.json and merge this configuration:

{
  "mcpServers": {
    "ai4scholar": {
      "url": "https://mcp.ai4scholar.net/sse",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Choose either method. After starting Gemini CLI, enter /mcp to view the tools, or run gemini mcp list to check the connection.

Gemini CLI uses url for SSE endpoints and httpUrl for Streamable HTTP. This guide uses url. See the Gemini CLI MCP documentation.

OpenCode

Edit your project's opencode.json or the global configuration at ~/.config/opencode/opencode.json, and add this entry under mcp:

{
  "mcp": {
    "ai4scholar": {
      "type": "remote",
      "url": "https://mcp.ai4scholar.net/sse",
      "enabled": true,
      "oauth": false,
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

After saving, reload OpenCode and run opencode mcp list to check the service status. This setup uses API key authentication, so oauth is set to false. See the OpenCode MCP documentation for field descriptions.

TRAE

Open MCP → Add → Add manually, paste the configuration, and replace the API key:

{
  "mcpServers": {
    "ai4scholar": {
      "type": "sse",
      "url": "https://mcp.ai4scholar.net/sse",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

After saving, check the service status and enable the ai4scholar tools in the agent you use.

Claude Desktop

Connect to the cloud service through a custom connector. First check whether your connector settings offer Request headers. This feature is still limited to certain accounts or organizations.

If the option is available:

1. Add a custom connector under Customize → Connectors. Organization administrators may find this in organization settings.
2. Enter ai4scholar as the name and https://mcp.ai4scholar.net/sse as the MCP server URL.
3. Select No sign-in for authentication, then add Authorization under Request headers with the value Bearer YOUR_API_KEY.
4. After saving, enable it in the conversation's connector menu and test a search.

Here, No sign-in means OAuth login is not used; the API key is still sent in the header. If Request headers is unavailable, use another client on this page that supports SSE and custom headers. See the Claude custom connector documentation for availability and interface details.

Codex

The official Codex MCP documentation lists Streamable HTTP as the remote connection transport, with support for bearer tokens or custom headers. This guide provides an SSE endpoint, and the two transports are not interchangeable.

First confirm that your client version and the server are compatible with this SSE URL. An HTTP URL field alone does not establish SSE support. If the client supports only Streamable HTTP, connect using one of the SSE-compatible clients above.

CC-Switch

CC-Switch can manage MCP configurations centrally and sync them to selected clients.

1. Open MCP management and add a custom server.
2. Select SSE as the transport and enter https://mcp.ai4scholar.net/sse as the URL.
3. Add an Authorization header with the value Bearer YOUR_API_KEY.
4. Select compatible clients to sync, such as Claude Code or Gemini CLI, then save and enable the service.
5. Return to each target client and check its connection status and tool list.

After syncing, you must still complete verification in the target client. Syncing configuration does not change that client's transport support.

Verify the connection and start using it

First confirm that the client shows the service as connected and lists Ai4Scholar search tools. Then send this request in a conversation with MCP enabled:

Use Ai4Scholar to search Semantic Scholar for papers about Transformers. Return 5 papers with their titles, authors, years, and source links.

A tool-call record followed by paper information confirms that setup and invocation have succeeded. You can then ask for a paper's abstract, citations, or related research. Available capabilities depend on the tool list currently loaded.

Academic API calls through MCP consume credits according to the rules of the corresponding Ai4Scholar service. See Credits and plans. Client model subscriptions and model API charges are billed separately by the relevant platform.

FAQ

401 or Unauthorized

Check that the header name is Authorization and its value is Bearer followed by the complete key. Confirm that you replaced YOUR_API_KEY, included no extra quotes, spaces, or line breaks, and used an Ai4Scholar API key. If needed, check the key's status in API key management.

Connection timeout, 405, or transport mismatch

First verify the complete URL, https://mcp.ai4scholar.net/sse, and the SSE transport setting. Then check whether the client and its runtime environment can reach that URL. If the client supports only Streamable HTTP, choose a compatible option as described above.

Connected, but the conversation does not call tools

Check that the server is enabled, Ai4Scholar is selected in the current conversation or agent, and the chosen model and conversation mode support tool calls. Reload the tools or start a new session, then retry the search example above.

Other MCP services are already configured

Merge the new entry into the existing configuration; do not overwrite the whole file. Most examples use mcpServers, while OpenCode uses mcp. Separate adjacent entries with commas and do not add a trailing comma after the last entry.