ChatGPT

Overview

Integrate CodeAlive with ChatGPT to enhance your AI conversations with deep codebase understanding. ChatGPT can access your indexed repositories through CodeAlive’s API using Custom GPTs with Actions.

Prerequisites

ChatGPT Plus, Team, or Enterprise subscription (required for Custom GPTs with Actions)
CodeAlive account with API key (Sign up here)
Indexed repositories in your CodeAlive dashboard

Integration Methods

Custom GPT (Recommended)
Direct API Calls

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.0",
  "info": {
    "title": "CodeAlive API",
    "version": "1.0.0"
  },
  "servers": [
    {
      "url": "https://app.codealive.ai/api"
    }
  ],
  "paths": {
    "/datasources/all": {
      "get": {
        "operationId": "getDataSources",
        "summary": "List available repositories",
        "security": [{"bearerAuth": []}]
      }
    },
    "/search": {
      "post": {
        "operationId": "searchCode",
        "summary": "Search code semantically",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "query": {"type": "string"},
                  "repositories": {
                    "type": "array",
                    "items": {"type": "string"}
                  }
                }
              }
            }
          }
        },
        "security": [{"bearerAuth": []}]
      }
    },
    "/chat/completions": {
      "post": {
        "operationId": "chatCompletions",
        "summary": "Get contextual code assistance",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "messages": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "properties": {
                        "role": {"type": "string"},
                        "content": {"type": "string"}
                      }
                    }
                  }
                }
              }
            }
          }
        },
        "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/search \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "authentication logic"}'

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

Getting Started

Features

Model Context Protocol

Agent Skills & Plugins

Overview

Prerequisites

Integration Methods

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

Getting Started

Features

Model Context Protocol

Agent Skills & Plugins

​Overview

​Prerequisites

​Integration Methods

​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

Overview

Prerequisites

Integration Methods

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