ChatGPT

Overview

Connect ChatGPT to CodeAlive’s remote MCP server with browser OAuth. The older Custom GPT Actions integration remains available as an API-key fallback.

Prerequisites

ChatGPT Business, Enterprise, or Edu workspace with custom MCP apps enabled
CodeAlive account (Sign up here)
Indexed repositories in your CodeAlive dashboard

Integration Methods

Custom MCP app (Recommended)
Custom GPT Action (API key)
Direct API Calls

Create a CodeAlive app in ChatGPT

Enable developer mode

A workspace admin enables Developer mode / Create custom MCP connectors under Workspace Settings → Permissions & Roles → Connected Data. Enterprise and Edu workspaces can grant this through RBAC.

Create the app

In Settings → Apps → Create, enter the CodeAlive MCP endpoint:

https://mcp.codealive.ai/api

Choose OAuth when ChatGPT asks for the authentication mechanism.

Authenticate and scan tools

Click Scan Tools, complete the CodeAlive browser sign-in and consent screen, then wait for ChatGPT to finish scanning. The app exposes read-only CodeAlive tools such as get_data_sources, semantic_search, grep_search, and read_file.

Test and publish

Select the draft app in a new chat and ask, “What CodeAlive repositories are available?” Workspace admins can publish the tested app and control access through ChatGPT’s app settings.

Each user authorizes their own CodeAlive access. Do not configure a shared API key for the MCP app.

Create a Custom GPT with CodeAlive

Custom GPTs allow you to create a specialized version of ChatGPT that connects to CodeAlive.

Create a New GPT

Go to chat.openai.com
Click on “Explore GPTs” in the sidebar
Click “Create” to build a new GPT

Configure GPT Instructions

Set up your GPT with these instructions:

You are a code assistant with access to CodeAlive, which provides
semantic search and analysis of entire codebases. You can:

1. Search for code implementations across repositories
2. Understand project architecture and patterns
3. Find related code and dependencies
4. Generate code following existing patterns

Always use CodeAlive to:
- Search for existing implementations before writing new code
- Understand the codebase context
- Follow established patterns and conventions

Add CodeAlive Action

Click on “Configure” → “Add Actions”
Import the CodeAlive OpenAPI schema:

{
  "openapi": "3.1.1",
  "info": {
    "title": "CodeAlive Tool API",
    "version": "3.0.0"
  },
  "servers": [
    {
      "url": "https://app.codealive.ai"
    }
  ],
  "paths": {
    "/api/tools/get_data_sources": {
      "post": {
        "operationId": "ToolApiGetDataSources",
        "summary": "List available repositories",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "additionalProperties": false,
                "properties": {
                  "query": {"type": "string"},
                  "ready_only": {"type": "boolean"},
                  "output_format": {"type": "string", "enum": ["json", "agentic"]}
                }
              }
            }
          }
        },
        "security": [{"bearerAuth": []}]
      }
    },
    "/api/tools/semantic_search": {
      "post": {
        "operationId": "ToolApiSemanticSearch",
        "summary": "Search code semantically",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "additionalProperties": false,
                "required": ["question"],
                "properties": {
                  "question": {"type": "string"},
                  "data_sources": {
                    "type": "array",
                    "items": {"type": "string"}
                  },
                  "paths": {"type": "array", "items": {"type": "string"}},
                  "extensions": {"type": "array", "items": {"type": "string"}},
                  "max_results": {"type": "integer"},
                  "output_format": {"type": "string", "enum": ["json", "agentic"]}
                }
              }
            }
          }
        },
        "security": [{"bearerAuth": []}]
      }
    },
    "/api/tools/chat": {
      "post": {
        "operationId": "ToolApiChat",
        "summary": "Ask a stateless question about code",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "additionalProperties": false,
                "required": ["question"],
                "properties": {
                  "question": {"type": "string"},
                  "data_sources": {
                    "type": "array",
                    "items": {"type": "string"}
                  },
                  "output_format": {"type": "string", "enum": ["json", "agentic"]}
                }
              }
            }
          }
        },
        "security": [{"bearerAuth": []}]
      }
    }
  },
  "components": {
    "securitySchemes": {
      "bearerAuth": {
        "type": "http",
        "scheme": "bearer"
      }
    }
  }
}

Add Authentication

In the Actions configuration, click “Authentication”
Select “API Key”
Auth Type: “Bearer”
Add your CodeAlive API key

Test Your GPT

Test with queries like:

“What repositories are available in CodeAlive?”
“Search for authentication implementations”
“Explain the user service architecture”

Use CodeAlive API Directly in ChatGPT

You can also manually provide API responses to ChatGPT for analysis.

Make API Request

Use curl or any HTTP client to query CodeAlive:

curl -X POST https://app.codealive.ai/api/tools/semantic_search \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"question": "Where is authentication implemented?", "data_sources": ["your-repo-name"], "output_format": "agentic"}'

Share with ChatGPT

Copy the API response and paste it into ChatGPT with context:

Here's the code search result from my codebase.
Please analyze this authentication implementation:

[Paste API response]

Usage Examples

Code Search

User: "Search my codebase for payment processing logic"

ChatGPT: [Uses CodeAlive action to search]
        Found payment processing in:
        - /services/payment/processor.js
        - /api/routes/checkout.js
        - /lib/payment-gateway.js

Architecture Analysis

User: "Explain how the authentication flow works"

ChatGPT: [Searches for auth code via CodeAlive]
        [Analyzes the flow across multiple files]
        [Provides detailed explanation with code references]

Code Generation

User: "Create a new API endpoint following our patterns"

ChatGPT: [Searches for existing endpoints]
        [Identifies patterns and conventions]
        [Generates code matching your style]

Advanced Configuration

Custom GPT Capabilities

Configure your GPT with specific capabilities:

{
  "capabilities": {
    "web_browsing": false,
    "dall_e_image_generation": false,
    "code_interpreter": true
  },
  "actions": ["codealive"],
  "conversation_starters": [
    "Search for implementations of...",
    "Explain the architecture of...",
    "Find all references to...",
    "Generate code similar to..."
  ]
}

Rate Limiting

Be aware of rate limits:

ChatGPT has limits on Actions calls per conversation
CodeAlive API has rate limits based on your plan
Use specific queries to minimize API calls

Privacy Settings

For team/enterprise accounts:

Control data sharing in GPT settings
Set action permissions (private, team, public)
Configure audit logging if required

Make it Public

Go to GPT settings
Click “Publish” → “Public”
Share the GPT link with others
Users will need their own CodeAlive API key

For ChatGPT Team/Enterprise:

Set visibility to “Anyone at [Your Organization]”
Team members can use shared authentication
Centrally manage API keys

Best Practices

Specific Queries

Use precise search terms to get relevant results

Context Windows

Be mindful of token limits when searching large codebases

Caching

Reuse search results within the same conversation

Security

Never share API keys in conversation

Troubleshooting

Action fails with authentication error

Solutions:

Verify API key is correct
Check key hasn’t expired
Ensure Bearer prefix is included
Regenerate key if needed

No results from searches

Solutions:

Verify repositories are indexed
Check search query syntax
Test API directly with curl
Check rate limits

GPT not using CodeAlive action

Solutions:

Explicitly ask to “use CodeAlive”
Check action is enabled
Verify OpenAPI schema is valid
Review GPT instructions

Rate limit exceeded

Solutions:

Reduce frequency of searches
Use more specific queries
Upgrade CodeAlive plan
Cache results when possible

For more solutions, see the Troubleshooting Guide.

Limitations

Current Limitations:

ChatGPT can’t maintain persistent connections
Actions have timeout limits (30 seconds)
Token limits may truncate large responses
No real-time code updates

Alternatives

If ChatGPT doesn’t meet your needs, consider:

Claude Code

Native MCP support with real-time updates

Cursor

IDE-integrated AI with MCP

Continue

Open-source alternative with MCP

API Direct

Build custom integration

Instruct Your Agent

Connecting CodeAlive makes its tools available, but the agent may still default to its built-in search. For reliable results, add a short instruction in the agent’s native format telling it to prefer semantic_search and grep_search when exploring indexed code. See Instructing Coding Agents.

Getting Started

Features

Model Context Protocol

Agent Skills & Plugins

Instructing Agents

Overview

Prerequisites

Integration Methods

Create a CodeAlive app in ChatGPT

Create a Custom GPT with CodeAlive

Use CodeAlive API Directly in ChatGPT

Usage Examples

Code Search

Architecture Analysis

Code Generation

Advanced Configuration

Custom GPT Capabilities

Rate Limiting

Privacy Settings

Make it Public

Best Practices

Specific Queries

Context Windows

Caching

Security

Troubleshooting

Limitations

Alternatives

Claude Code

Cursor

Continue

API Direct

Instruct Your Agent

​Overview

​Prerequisites

​Integration Methods

​Create a CodeAlive app in ChatGPT

​Create a Custom GPT with CodeAlive

​Use CodeAlive API Directly in ChatGPT

​Usage Examples

​Code Search

​Architecture Analysis

​Code Generation

​Advanced Configuration

​Custom GPT Capabilities

​Rate Limiting

​Privacy Settings

​Sharing Your GPT

​Make it Public

​Team Sharing

​Best Practices

Specific Queries

Context Windows

Caching

Security

​Troubleshooting

​Limitations

​Alternatives

Claude Code

Cursor

Continue

API Direct

​Related Resources

​Instruct Your Agent

Overview

Prerequisites

Integration Methods

Create a CodeAlive app in ChatGPT

Create a Custom GPT with CodeAlive

Use CodeAlive API Directly in ChatGPT

Usage Examples

Code Search

Architecture Analysis

Code Generation

Advanced Configuration

Custom GPT Capabilities

Rate Limiting

Privacy Settings

Sharing Your GPT

Make it Public

Team Sharing

Best Practices

Troubleshooting

Limitations

Alternatives

Related Resources

Instruct Your Agent