Continue.dev 아키텍처 상세 분석

게시 2026/01/31

By BLUEBUG

75 분읽는 시간

오픈소스 AI 코딩 어시스턴트의 기술적 구조와 진화

서론: Continue.dev의 위치와 철학

Continue.dev는 2026년 현재 가장 주목받는 오픈소스 AI 코딩 어시스턴트 중 하나입니다. GitHub에서 30,000개 이상의 스타를 받으며, 개발자 커뮤니티에서 “진정한 개발자 중심 AI 도구”로 평가받고 있습니다. Continue는 독점적 솔루션들과 달리 근본적으로 다른 철학을 기반으로 설계되었습니다. 바로 “Your code, your AI, your rules” - 개발자가 모든 것을 통제할 수 있어야 한다는 원칙입니다.

이 철학은 아키텍처의 모든 층위에 반영되어 있습니다. Continue는 특정 AI 모델에 종속되지 않으며, 특정 클라우드 서비스를 강제하지 않고, 심지어 완전히 오프라인 환경에서도 작동할 수 있도록 설계되었습니다. 이러한 접근은 GitHub Copilot의 “OpenAI 종속성”이나 Cursor의 “독점 모델 의존성”과 명확하게 대비됩니다.

Continue의 아키텍처를 이해하는 것은 단순히 하나의 도구를 이해하는 것을 넘어, 현대 AI 개발 도구가 어떻게 설계되어야 하는지에 대한 청사진을 보는 것과 같습니다. 오픈소스 커뮤니티가 수년간 축적한 최고의 실천 방법들이 이 아키텍처에 녹아들어 있기 때문입니다.

핵심 아키텍처: 3-Layer 분리 설계

Continue.dev의 아키텍처는 명확한 관심사의 분리(Separation of Concerns) 원칙을 따릅니다. 시스템은 세 개의 주요 레이어로 구성되며, 각 레이어는 독립적으로 발전하면서도 표준화된 프로토콜을 통해 소통합니다.

아키텍처 개요

┌─────────────────────────────────────────────────┐
│              GUI Layer (React)                  │
│          사용자 인터페이스 및 시각화              │
└─────────────────┬───────────────────────────────┘
                  │ Protocol Messages
                  │ (JSON-RPC style)
┌─────────────────▼───────────────────────────────┐
│         Extension Layer (VS Code/JetBrains)     │
│         IDE 통합 및 이벤트 브리징                │
└─────────────────┬───────────────────────────────┘
                  │ Protocol Interface
                  │ (core/protocol)
┌─────────────────▼───────────────────────────────┐
│            Core Layer (TypeScript)              │
│    비즈니스 로직, AI 통합, 설정 관리             │
└─────────────────────────────────────────────────┘

이 3-Layer 아키텍처는 다음과 같은 장점을 제공합니다:

첫째, 플랫폼 독립성입니다. Extension Layer만 IDE별로 다르게 구현하면 되므로, VS Code와 JetBrains 같은 전혀 다른 에코시스템을 동시에 지원할 수 있습니다. Core와 GUI는 완전히 동일한 코드베이스를 공유하며, 이는 기능 개발 속도를 크게 향상시킵니다.

둘째, 테스트 용이성입니다. 각 레이어는 명확한 인터페이스를 통해 통신하므로, 단위 테스트와 통합 테스트가 매우 수월합니다. Core Layer는 IDE 환경 없이도 독립적으로 테스트할 수 있으며, GUI는 모의(Mock) Extension을 통해 격리된 환경에서 테스트할 수 있습니다.

셋째, 유지보수성입니다. 버그 수정이나 새 기능 추가 시, 영향 범위가 명확하게 정의됩니다. 예를 들어 새로운 AI 모델을 추가한다면 Core Layer만 수정하면 되고, UI 개선은 GUI Layer만, IDE별 특수 기능은 Extension Layer만 건드리면 됩니다.

1. GUI Layer: 사용자 경험의 최전선

GUI Layer는 React와 Redux Toolkit을 기반으로 구축되었습니다. 이는 현대 웹 개발의 표준 스택을 그대로 활용한 것으로, 숙련된 프론트엔드 개발자라면 누구나 쉽게 기여할 수 있는 환경을 조성합니다.

상태 관리 아키텍처 는 Redux Toolkit의 철학을 따릅니다. 모든 사용자 상호작용은 액션(Action)으로 변환되고, 이 액션들은 리듀서(Reducer)를 통해 상태를 변경합니다. 중요한 점은 GUI Layer 자체는 “어리석은(Dumb)” 컴포넌트로 설계되어 있다는 것입니다. 실제 비즈니스 로직은 Core Layer에 있으며, GUI는 단지 현재 상태를 시각화하고 사용자 입력을 전달하는 역할만 수행합니다.

메시지 프로토콜을 통한 통신은 매우 흥미롭습니다. GUI는 Extension Layer와 JSON-RPC 스타일의 메시지를 주고받는데, 이는 마치 클라이언트-서버 아키텍처처럼 작동합니다. 예를 들어, 사용자가 채팅창에 질문을 입력하면:

GUI가 chat/sendMessage 액션을 디스패치합니다
이 액션은 Extension Layer로 전달됩니다
Extension은 이를 Core Layer로 라우팅합니다
Core가 AI 모델과 통신하여 응답을 생성합니다
응답이 역순으로 GUI까지 전달되어 화면에 표시됩니다

이런 설계 덕분에 GUI는 AI 모델이 로컬인지, 클라우드인지, 어떤 모델인지 전혀 알 필요가 없습니다. 단지 “메시지를 보내고 응답을 받는다”는 추상화된 인터페이스만 알면 됩니다.

컴포넌트 구조 는 기능별로 명확하게 분리되어 있습니다:

Chat Components: 대화형 인터페이스를 제공하며, 메시지 히스토리, 코드 블록 렌더링, 마크다운 지원 등을 포함합니다
Plan Components: 계획 모드의 UI로, 제안된 변경사항을 트리 구조로 시각화합니다
Agent Components: 에이전트 모드의 실행 상태, 진행률, 도구 사용 내역을 표시합니다
Settings Components: 모델 선택, 컨텍스트 제공자 설정, 규칙 편집 등을 담당합니다

2. Extension Layer: IDE와 Core의 브리지

Extension Layer는 Continue 아키텍처에서 가장 “더러운 일”을 담당하는 레이어입니다. 각 IDE는 서로 완전히 다른 API와 이벤트 모델을 가지고 있지만, Extension Layer는 이러한 차이를 흡수하여 Core에게 일관된 인터페이스를 제공합니다.

VS Code Extension 구현 은 TypeScript로 작성되며, VS Code Extension API를 직접 사용합니다. 주요 책임은 다음과 같습니다:

IDE 이벤트 감지 및 변환: 파일 열기, 저장, 편집 등의 이벤트를 캡처하여 Core가 이해할 수 있는 형태로 변환합니다
웹뷰 호스팅: React로 작성된 GUI를 VS Code의 웹뷰 패널에 렌더링합니다
파일 시스템 접근: Core가 요청하는 파일 읽기/쓰기 작업을 실제로 수행합니다
터미널 제어: 명령어 실행, 출력 캡처 등을 처리합니다

JetBrains Extension 구현 은 Kotlin과 IntelliJ Platform SDK를 사용합니다. 이는 VS Code Extension과 완전히 다른 언어와 프레임워크이지만, Core와의 인터페이스는 동일합니다. JetBrains의 경우 추가적인 복잡성이 있는데, PyCharm, WebStorm, IntelliJ IDEA 등 여러 IDE를 모두 지원해야 하기 때문입니다. 하지만 다행히 이들은 모두 IntelliJ Platform을 공유하므로, 단일 Extension 구현으로 모든 JetBrains IDE를 커버할 수 있습니다.

VsCodeMessenger 클래스 는 Extension Layer의 핵심입니다. 이 클래스는 중앙 메시지 라우터로 작동하며, 다음 세 방향의 메시지 흐름을 조정합니다:

  
// 개념적 구조 (실제 코드는 더 복잡합니다)
class VsCodeMessenger {
  // GUI -> Core 메시지 전달
  handleGuiMessage(message) {
    const coreMessage = this.translateToCore(message);
    return this.core.handleMessage(coreMessage);
  }
  
  // Core -> GUI 메시지 전달
  sendToGui(message) {
    const guiMessage = this.translateToGui(message);
    this.webview.postMessage(guiMessage);
  }
  
  // IDE 이벤트 -> Core 알림
  onFileChange(uri) {
    this.core.notifyFileChange(uri);
  }
}

프로토콜 인터페이스 는 core/protocol 폴더에 정의되어 있으며, TypeScript 인터페이스로 엄격하게 타입이 지정됩니다. 새로운 메시지 타입을 추가하려면 이 폴더의 적절한 파일에 추가해야 하며, 이는 컴파일 타임에 타입 안전성을 보장합니다.

3. Core Layer: 두뇌의 역할

Core Layer는 Continue의 진정한 두뇌입니다. 모든 비즈니스 로직, AI 통합, 설정 관리가 이곳에 집중되어 있습니다. Core는 IDE와 완전히 독립적으로 설계되었으며, 이론적으로는 CLI 도구로도 사용할 수 있습니다 (실제로 2026년 업데이트에서 CLI 모드가 추가되었습니다).

설정 관리 시스템 은 Core의 가장 중요한 책임 중 하나입니다. Continue는 config.json 또는 config.yaml 파일을 통해 광범위하게 설정할 수 있습니다. 확장이 로드될 때, Core는 다음 순서로 설정을 로드합니다:

기본 설정 파일 검색 (~/.continue/config.yaml 또는 프로젝트 내 .continue/config.yaml)
환경 변수 오버라이드 적용
설정 파일 파싱 및 검증
모델, 컨텍스트 제공자, 슬래시 커맨드 등 초기화

설정 파일의 구조는 다음과 같은 주요 섹션으로 나뉩니다:

  
# 모델 정의 - 역할별로 다른 모델 사용 가능
models:
  - role: chat
    provider: anthropic
    model: claude-sonnet-4-5-20250929
    apiKey: ${ANTHROPIC_API_KEY}
  
  - role: autocomplete
    provider: ollama
    model: deepseek-coder:1.3b
  
  - role: edit
    provider: openai
    model: gpt-4o
    apiKey: ${OPENAI_API_KEY}

# 컨텍스트 제공자 - 어떤 정보를 AI에게 제공할지
contextProviders:
  - name: code
    params:
      includeTests: true
  
  - name: docs
    params:
      urls:
        - https://docs.continue.dev
  
  - name: terminal
  
  - name: problems

# 시스템 메시지 - AI의 행동 규칙
systemMessage: |
  You are an expert software engineer.
  Always write clean, well-documented code.
  Follow the team's coding standards in .continue/rules/

# 슬래시 커맨드 - 커스텀 단축 명령
slashCommands:
  - name: test
    description: Generate unit tests
    prompt: Write comprehensive unit tests for the selected code

# MCP 서버 - 외부 도구 통합
mcpServers:
  - name: github
    command: npx
    args:
      - "@modelcontextprotocol/server-github"

AI 모델 통합 레이어 는 놀라울 정도로 유연합니다. Continue는 “모델 제공자(Provider)” 추상화를 통해 거의 모든 LLM을 지원합니다:

OpenAI Provider: GPT-4, GPT-4o, o1 등 OpenAI 모델
Anthropic Provider: Claude 3/4 모델 패밀리
Ollama Provider: 로컬 LLM (Llama, Mistral, DeepSeek 등)
LM Studio Provider: 로컬 모델 서빙
Azure Provider: Azure OpenAI Service
Gemini Provider: Google의 Gemini 모델
Custom Provider: 임의의 OpenAI 호환 API

각 제공자는 공통 인터페이스를 구현하며, Core는 이 인터페이스를 통해 모델과 통신합니다:

  
interface ModelProvider {
  // 채팅 완성 생성
  streamChat(messages: Message[]): AsyncGenerator<string>;
  
  // 코드 완성 (autocomplete)
  complete(prefix: string, suffix: string): Promise<string>;
  
  // 임베딩 생성 (의미적 검색용)
  embed(text: string): Promise<number[]>;
  
  // 재순위 지정 (검색 결과 정렬)
  rerank(query: string, documents: string[]): Promise<number[]>;
}

컨텍스트 수집 시스템 은 Core의 또 다른 핵심 기능입니다. AI가 유용한 응답을 생성하려면 관련 컨텍스트가 필요한데, Continue는 다양한 “컨텍스트 제공자”를 통해 이를 수집합니다:

Code Provider: 현재 파일, 선택된 코드, 열린 파일들
Docs Provider: URL로 지정된 문서를 크롤링하고 인덱싱
Git Provider: 커밋 히스토리, diff, 브랜치 정보
Terminal Provider: 최근 터미널 출력
Problems Provider: IDE가 감지한 에러와 경고
Folder Provider: 프로젝트 구조 및 파일 목록
URL Provider: 웹 페이지 내용 가져오기

각 제공자는 필요에 따라 on-demand로 실행되거나, 백그라운드에서 지속적으로 정보를 수집합니다. 예를 들어 Docs Provider는 시작 시 한 번 문서를 인덱싱하고, 그 후 로컬 벡터 데이터베이스에서 빠르게 검색합니다.

에이전트 실행 엔진 은 2025년 후반부터 Core의 중요한 부분이 되었습니다. Agent 모드에서 Continue는 단순히 응답을 생성하는 것이 아니라, 실제로 코드를 작성하고, 파일을 수정하며, 명령어를 실행합니다. 이를 위한 실행 루프는 다음과 같습니다:

사용자 목표 받기
현재 상태 분석 (코드베이스, 에러 등)
다음 행동 결정 (AI가 결정)
도구 실행 (파일 수정, 명령어 실행 등)
결과 관찰
목표 달성 여부 평가
미달성 시 2번으로 돌아가기

이 루프는 ReAct (Reasoning + Acting) 패턴을 따르며, AI가 각 단계에서 “왜 이 행동을 하는지” 설명하도록 강제합니다. 이는 투명성과 디버깅 가능성을 크게 향상시킵니다.

Model Context Protocol (MCP) 통합: 생태계로의 개방

2024년 말 Anthropic이 MCP를 발표했을 때, Continue는 최초로 전체 MCP 기능을 지원하는 클라이언트가 되었습니다. 이는 Continue 아키텍처의 개방성과 확장성을 보여주는 완벽한 사례입니다.

MCP 아키텍처 개요

MCP는 “AI를 위한 USB-C”로 비유됩니다. USB-C가 다양한 장치와 프로토콜을 단일 커넥터로 통합했듯이, MCP는 다양한 도구와 데이터 소스를 표준화된 프로토콜로 AI에 연결합니다.

┌─────────────────────────────────────────────────┐
│           Continue.dev (MCP Host)               │
│                                                 │
│  ┌─────────────────────────────────────────┐   │
│  │  Core Layer - MCP Client                │   │
│  │  - Server Discovery                     │   │
│  │  - Protocol Communication               │   │
│  │  - Tool Orchestration                   │   │
│  └──────┬──────────┬──────────┬─────────┬──┘   │
│         │          │          │         │      │
└─────────┼──────────┼──────────┼─────────┼──────┘
          │          │          │         │
    MCP Protocol (stdio / HTTP / SSE)
          │          │          │         │
┌─────────▼──┐  ┌────▼────┐  ┌─▼─────┐  ┌▼────────┐
│ GitHub     │  │Database │  │Browser│  │Slack    │
│ MCP Server │  │MCP Server│  │MCP    │  │MCP      │
│            │  │         │  │Server │  │Server   │
│- Issues    │  │- Query  │  │- Nav  │  │- Send   │
│- PRs       │  │- Schema │  │- Click│  │- Read   │
│- Search    │  │- Write  │  │- Shot │  │- Search │
└────────────┘  └─────────┘  └───────┘  └─────────┘

MCP의 4가지 핵심 개념

MCP는 네 가지 기본 요소로 구성되며, Continue는 이 모든 요소를 완벽하게 지원합니다:

1. Resources (리소스) 는 AI가 읽을 수 있는 데이터입니다. 예를 들어:

GitHub MCP: 이슈, PR, 파일 내용
Database MCP: 테이블 스키마, 쿼리 결과
Docs MCP: 문서 페이지, API 레퍼런스

Continue의 기존 “컨텍스트 제공자”는 자연스럽게 MCP Resources로 매핑됩니다. 사용자가 “@github”를 입력하면, Continue는 GitHub MCP Server의 리소스 목록을 가져와 자동완성으로 보여줍니다.

2. Prompts (프롬프트) 는 사전 정의된 템플릿입니다:

“이 코드 리뷰해줘” → 구조화된 리뷰 프롬프트
“테스트 작성해줘” → 테스트 생성 프롬프트

Continue의 슬래시 커맨드와 MCP Prompts가 통합되어, MCP Server가 제공하는 프롬프트를 / 명령으로 직접 사용할 수 있습니다.

3. Tools (도구) 는 AI가 실행할 수 있는 액션입니다:

GitHub MCP: create_issue, comment_on_pr
Database MCP: execute_query, create_table
Slack MCP: send_message, create_channel

이는 Continue의 Agent 모드와 완벽하게 통합됩니다. 에이전트가 “Slack에 배포 완료 메시지 보내줘”라고 요청받으면:

Slack MCP Server의 send_message 도구를 발견
적절한 파라미터로 도구 호출
결과를 사용자에게 보고

4. Sampling (샘플링) 은 MCP Server가 역으로 LLM에게 질문할 수 있는 고급 기능입니다. 예를 들어:

Database MCP가 복잡한 쿼리 결과를 받았을 때, LLM에게 “이걸 어떻게 요약할까?”라고 물어볼 수 있습니다
Browser MCP가 HTML을 파싱한 후, “이 페이지의 핵심 정보가 뭐야?”라고 LLM에게 확인할 수 있습니다

MCP 서버 설정 및 관리

Continue는 2026년 업데이트에서 MCP 설정을 크게 간소화했습니다. 이제 두 가지 방식으로 MCP 서버를 추가할 수 있습니다:

방식 1: YAML 설정 파일

프로젝트 루트에 .continue/mcpServers/ 폴더를 생성하고, YAML 파일을 추가합니다:

  
# .continue/mcpServers/playwright-mcp.yaml
name: Playwright MCP Server
version: 0.0.1
schema: v1

mcpServers:
  - name: Browser search
    command: npx
    args:
      - "@playwright/mcp@latest"

방식 2: JSON 설정 파일 (Claude Desktop 호환)

Claude Desktop, Cursor, Cline 등에서 사용하던 JSON 설정을 그대로 복사할 수 있습니다:

  
// .continue/mcpServers/mcp.json
{
  "mcpServers": {
    "sqlite": {
      "command": "npx",
      "args": ["-y", "mcp-sqlite", "/path/to/database.db"]
    },
    "github": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

Continue는 이 파일들을 자동으로 감지하고 로드합니다. 환경 변수 템플릿(${VAR_NAME})도 자동으로 치환됩니다.

방식 3: 메인 설정 파일에 직접 추가

  
# config.yaml
mcpServers:
  - name: SQLite MCP
    command: npx
    args:
      - "-y"
      - "mcp-sqlite"
      - "/path/to/your/database.db"
  
  - name: Local FastMCP Server
    type: sse  # Server-Sent Events
    url: http://localhost:8000/sse

Transport 프로토콜

MCP는 세 가지 전송 방식을 지원하며, Continue는 모두 지원합니다:

1. STDIO (Standard Input/Output)

로컬 프로세스와 텍스트 기반 통신
대부분의 MCP 서버가 사용하는 기본 방식
가장 간단하고 안정적

  
mcpServers:
  - name: Local SQLite
    type: stdio  # 기본값이므로 생략 가능
    command: npx
    args: ["mcp-sqlite", "/path/to/db.sqlite"]

2. HTTP (RESTful)

원격 서버와 통신
클라우드 호스팅 MCP 서버에 사용
인증, 로드 밸런싱 등 가능

  
mcpServers:
  - name: Remote MCP
    type: http
    url: https://mcp.example.com
    headers:
      Authorization: Bearer ${API_TOKEN}

3. SSE (Server-Sent Events)

실시간 스트리밍 데이터
서버가 능동적으로 클라이언트에게 푸시
로그 모니터링, 실시간 알림 등에 유용

  
mcpServers:
  - name: Log Monitor
    type: sse
    url: http://localhost:8000/sse

MCP 보안과 권한 관리

MCP 서버는 강력한 만큼 위험할 수 있습니다. Continue는 다단계 보안 메커니즘을 제공합니다:

1. Roots (작업 경계)

MCP 서버에게 “안전 영역”을 정의합니다:

  
mcpServers:
  - name: Filesystem MCP
    command: npx
    args: ["@modelcontextprotocol/server-filesystem"]
    roots:
      - file:///home/user/projects/myapp
      - file:///home/user/documents/specs

서버는 이 디렉토리 밖의 파일에 접근할 수 없습니다.

2. Permission System (권한 시스템)

Continue의 Agent 모드는 세밀한 권한 제어를 지원합니다:

  
# .continue/rules/permissions.yaml
permissions:
  - allow: git_*  # 모든 git 명령 허용
  
  - confirm:  # 확인 필요
      - file_write: "*.ts"
      - file_delete: "*"
  
  - deny:  # 금지
      - file_write: "*.env"
      - bash: "rm -rf *"

3. Environment Variable Protection (환경 변수 보호)

민감한 정보는 절대 설정 파일에 직접 쓰지 않습니다:

  
# ❌ 나쁜 예
mcpServers:
  - name: GitHub
    env:
      GITHUB_TOKEN: ghp_abc123...  # 절대 이렇게 하지 마세요!

# ✅ 좋은 예
mcpServers:
  - name: GitHub
    env:
      GITHUB_TOKEN: ${GITHUB_TOKEN}  # 환경 변수 참조

Continue는 시스템 환경 변수나 .env 파일에서 이 값을 로드합니다.

Docker 컨테이너화된 MCP 서버

2025년 Continue와 Docker의 파트너십 이후, MCP 서버를 Docker 컨테이너로 실행하는 것이 표준이 되었습니다. 이는 다음 장점을 제공합니다:

격리성: 서버가 호스트 시스템에 영향을 주지 않습니다 재현성: 개발, 테스트, 프로덕션에서 동일하게 작동합니다 보안: 컨테이너 이미지 스캔, 서명, 검증이 가능합니다 의존성 관리: npx, uv 등의 무작위 설치를 피합니다

  
# .continue/mcpServers/docker-mcp.yaml
mcpServers:
  - name: FFmpeg MCP
    type: docker
    image: continue/mcp-ffmpeg:latest
    mounts:
      - /path/to/videos:/videos

Continue Hub는 검증된 Docker 이미지를 제공하며, 기업은 이를 내부 레지스트리에 미러링하여 공급망 보안을 강화할 수 있습니다.

MCP 생태계: 주요 서버들

2026년 현재, Continue와 함께 사용할 수 있는 MCP 서버는 수백 개에 달합니다. 주요 서버들을 살펴보겠습니다:

개발 도구

GitHub MCP: 이슈, PR, 검색, 코드 리뷰
GitLab MCP: MR, 파이프라인, 이슈 트래킹
Linear MCP: 작업 관리, 스프린트 플래닝
Jira MCP: 티켓 생성, 업데이트, 검색

데이터베이스

SQLite MCP: 로컬 SQL 데이터베이스
PostgreSQL MCP: 엔터프라이즈 데이터베이스
MongoDB MCP: NoSQL 문서 저장소
Redis MCP: 캐시 및 세션 관리

클라우드 인프라

AWS MCP: EC2, S3, Lambda 제어
Azure MCP: 리소스 관리, 모니터링
GCP MCP: Compute Engine, Cloud Storage

지식 및 문서

Microsoft Learn MCP: 최신 기술 문서
Context7 MCP: 라이브러리 문서 (현재 버전)
Obsidian MCP: 개인 지식 베이스
Confluence MCP: 팀 위키

자동화 및 통합

Playwright MCP: 브라우저 자동화, 테스팅
n8n MCP: 로우코드 워크플로우
Slack MCP: 팀 커뮤니케이션
Email MCP: 이메일 송수신

개발 환경

Filesystem MCP: 안전한 파일 작업
Git MCP: 버전 관리
Terminal MCP: 명령어 실행
Desktop Commander: 터미널 + 프로세스 관리

실행 환경

E2B MCP: 클라우드 Code Interpreter
Sandbox MCP: 격리된 코드 실행

메모리 및 컨텍스트

Memory MCP: 지식 그래프 메모리
Sequential Thinking MCP: 단계별 추론 저장

커스텀 MCP 서버 개발

Continue의 가장 강력한 기능 중 하나는 개발자가 직접 MCP 서버를 만들 수 있다는 것입니다. FastMCP 프레임워크를 사용하면 몇 줄의 Python 코드로 서버를 구축할 수 있습니다:

  
# server.py
from fastmcp import FastMCP
import os

# MCP 서버 생성
mcp = FastMCP(
    name="Portland Parks Finder",
    host=os.getenv("HOST", "localhost"),
    port=int(os.getenv("PORT", 8000))
)

# 도구 정의
def find_nearby_park(location: str) -> str:
    """
    포틀랜드에서 위치 기반으로 가장 가까운 공원을 찾습니다.
    
    Args:
        location: 사용자 위치 (예: "downtown", "pearl district")
    
    Returns:
        추천 공원 이름과 설명
    """
    parks_db = {
        "downtown": "Director Park - 도심 속 녹색 오아시스",
        "pearl district": "Jamison Square - 인터랙티브 분수대",
        "southeast": "Laurelhurst Park - 넓은 잔디밭과 연못"
    }
    
    return parks_db.get(
        location.lower(),
        "PDX Parks 웹사이트에서 검색해보세요: pdxparks.org"
    )

# 리소스 정의
def list_all_parks():
    """모든 포틀랜드 공원 목록"""
    return {
        "uri": "parks://all",
        "mimeType": "application/json",
        "text": json.dumps({
            "parks": [
                {"name": "Director Park", "area": "Downtown"},
                {"name": "Jamison Square", "area": "Pearl District"},
                # ... 더 많은 공원
            ]
        })
    }

# 서버 실행
if __name__ == "__main__":
    mcp.run()

Continue 설정에 추가:

  
# .continue/mcpServers/portland-parks.yaml
mcpServers:
  - name: Portland Parks
    command: python
    args: ["/path/to/server.py"]
    env:
      HOST: localhost
      PORT: "8000"

이제 Continue의 Agent 모드에서:

User: 나 Pearl District에 있는데 가까운 공원 찾아줘

Agent: Portland Parks MCP 서버의 find_nearby_park 도구를 사용하겠습니다.
[Tool Call: find_nearby_park(location="pearl district")]
[Result: "Jamison Square - 인터랙티브 분수대"]

Jamison Square를 추천드립니다. Pearl District에 위치한 이 공원은 
독특한 인터랙티브 분수대로 유명하며, 도보로 쉽게 접근할 수 있습니다.

작동 모드: 세 가지 상호작용 패러다임

Continue는 사용자와 상호작용하는 세 가지 주요 모드를 제공하며, 각 모드는 서로 다른 사용 사례에 최적화되어 있습니다.

1. Chat 모드: 대화형 협업

Chat 모드는 Continue의 가장 직관적인 인터페이스입니다. 개발자는 IDE 내에서 AI와 자연어로 대화하며, 코드베이스의 완전한 컨텍스트를 유지하면서 질문하고 답변을 받을 수 있습니다.

컨텍스트 인식 대화 는 Chat 모드의 핵심입니다. 사용자가 “이 함수 설명해줘”라고 물으면, Continue는 자동으로:

현재 커서 위치의 함수를 인식
해당 함수의 전체 코드 가져오기
함수가 참조하는 다른 함수/클래스 찾기
관련 타입 정의, 임포트 문 수집
이 모든 컨텍스트와 함께 AI에게 질문 전달

개발자는 명시적으로 코드를 선택하거나 복사-붙여넣기할 필요가 없습니다. Continue가 자동으로 “올바른” 컨텍스트를 파악합니다.

@ 멘션 시스템을 통해 개발자는 명시적으로 컨텍스트를 추가할 수 있습니다:

@file: 특정 파일 전체 내용 포함
@folder: 디렉토리 구조 및 파일 목록
@code: 현재 선택된 코드
@terminal: 최근 터미널 출력
@docs: 인덱싱된 문서에서 검색
@git: Git diff, 커밋 메시지
@problems: IDE가 감지한 에러
@github: GitHub 이슈, PR (MCP 통합)
@database: 데이터베이스 스키마 (MCP 통합)

예를 들어:

User: @file src/auth.ts @terminal 이 인증 에러 뭐가 문제야?

Continue는 자동으로:
1. src/auth.ts 파일 전체를 읽습니다
2. 최근 터미널 출력 (아마도 에러 스택트레이스)을 가져옵니다
3. 이 두 정보를 AI에게 제공하여 에러 진단을 요청합니다

슬래시 커맨드 는 자주 사용하는 작업을 단축합니다:

/edit: 선택된 코드를 수정
/comment: 코드에 주석 추가
/fix: 에러 수정
/test: 단위 테스트 생성
/explain: 코드 설명
/docs: 문서 생성

커스텀 슬래시 커맨드도 설정 파일에서 정의할 수 있습니다:

  
slashCommands:
  - name: review
    description: Code review with team standards
    prompt: |
      Review the selected code for:
      1. Security vulnerabilities
      2. Performance issues
      3. Compliance with our coding standards in @rules
      4. Potential bugs
      
      Provide specific suggestions for improvement.

2. Plan 모드: 안전한 탐색

Plan 모드는 Continue의 독특한 기능으로, “읽기 전용 샌드박스”를 제공합니다. 이 모드에서 AI는 제안된 변경사항을 실제로 적용하지 않고 미리 보여줍니다.

작동 원리 는 다음과 같습니다:

사용자가 요청합니다: “이 컴포넌트를 TypeScript로 변환해줘”
Continue가 변경 계획을 수립합니다
파일별로 예상되는 변경사항을 보여줍니다 (diff 형식)
개발자가 각 변경을 검토합니다
승인하면 실제로 적용됩니다

이는 대규모 리팩토링이나 익숙하지 않은 코드베이스에서 특히 유용합니다. 개발자는 AI가 무엇을 할 것인지 정확히 알고 있으며, 원하지 않는 변경은 거부할 수 있습니다.

시각화 는 트리 구조로 제공됩니다:

📝 Convert React component to TypeScript
  ├─ 📄 src/components/Button.jsx
  │   └─ ✏️  Add TypeScript types for props
  │   └─ ✏️  Convert class component to FC
  │   └─ ✏️  Add proper return type
  │
  ├─ 📄 src/components/Button.test.jsx
  │   └─ ✏️  Rename to .tsx
  │   └─ ✏️  Update import paths
  │
  └─ 📄 package.json
      └─ ✏️  Add @types/react dependency

개발자는 각 항목을 클릭하여 상세한 diff를 보고, 체크박스로 적용 여부를 선택할 수 있습니다.

위험 완화 는 Plan 모드의 핵심 가치입니다:

실수로 중요한 코드 삭제 방지
예상치 못한 부작용 사전 확인
변경 범위 명확한 이해
단계별 적용 가능 (일부만 승인)

3. Agent 모드: 자율 실행

Agent 모드는 Continue의 가장 강력하고 위험한 기능입니다. 이 모드에서 AI는 단순히 제안하는 것이 아니라, 실제로 행동합니다.

자율 행동 루프 는 다음과 같이 작동합니다:

1. 목표 이해
   └─> 사용자: "API 통합 테스트 작성하고 실행해줘"

2. 계획 수립
   └─> Agent: "필요한 단계들을 분석합니다..."
       - 기존 테스트 프레임워크 확인
       - API 엔드포인트 파악
       - 테스트 케이스 설계
       - 테스트 파일 생성
       - 테스트 실행
       - 결과 분석

3. 도구 선택 및 실행
   └─> Agent: "파일 시스템 도구로 테스트 파일 생성..."
       [Tool: write_file("tests/api.test.ts", content)]
   
   └─> Agent: "터미널 도구로 테스트 실행..."
       [Tool: run_command("npm test")]

4. 결과 관찰
   └─> Agent: "테스트 3개 중 1개 실패. 에러 분석..."

5. 적응 및 재시도
   └─> Agent: "실패 원인 파악. 테스트 수정..."
       [Tool: edit_file("tests/api.test.ts", changes)]
   
   └─> Agent: "다시 실행..."
       [Tool: run_command("npm test")]

6. 완료 또는 반복
   └─> Agent: "모든 테스트 통과! 작업 완료."

사용 가능한 도구들:

기본 제공 도구:

read_file: 파일 내용 읽기
write_file: 새 파일 생성
edit_file: 기존 파일 수정
delete_file: 파일 삭제
list_directory: 디렉토리 목록
run_command: 터미널 명령 실행
search_codebase: 코드 검색
web_search: 웹 검색 (Continue Hub 통합)

MCP 도구들 (설정된 경우):

GitHub: create_issue, comment_on_pr, merge_pr
Database: execute_query, backup_database
Slack: send_message, create_channel
AWS: deploy_lambda, update_s3
등등… (설정된 MCP 서버에 따라)

안전 메커니즘:

Agent 모드는 강력하지만, 위험을 완화하기 위한 여러 메커니즘을 갖추고 있습니다:

확인 프롬프트: 위험한 작업 전 사용자 승인 요청 ``` Agent: 다음 파일을 삭제하려고 합니다:
- src/legacy/old_auth.ts
계속하시겠습니까? [y/N] ```

권한 시스템: 설정 파일로 허용/거부 제어

  
permissions:
  allow: ["read_file", "write_file", "run_command: npm *"]
  confirm: ["delete_file", "edit_file: *.config.js"]
  deny: ["run_command: rm -rf *", "run_command: sudo *"]

Dry Run 모드: 실제 실행 없이 시뮬레이션

User: /agent --dry-run "데이터베이스 마이그레이션 실행"
   
Agent: [DRY RUN] 다음 작업을 수행할 예정입니다:
1. 마이그레이션 파일 읽기
2. 데이터베이스 연결
3. 마이그레이션 실행
4. 검증 쿼리 실행
   
실제 변경사항은 적용되지 않습니다.

작업 로그: 모든 에이전트 행동 기록

[2026-01-31 14:23:45] Agent started: "Implement user authentication"
[2026-01-31 14:23:47] Tool call: read_file("src/user.ts")
[2026-01-31 14:23:50] Tool call: write_file("src/auth.ts", ...)
[2026-01-31 14:23:55] Tool call: run_command("npm install bcrypt")
[2026-01-31 14:24:02] Agent completed successfully

실제 사용 사례:

Agent 모드는 반복적이고 시간 소모적인 작업에 특히 유용합니다:

대규모 리팩토링: “모든 클래스 컴포넌트를 함수형으로 변환”
테스트 작성: “커버리지 80% 미만인 모든 파일에 테스트 추가”
문서화: “모든 public 함수에 JSDoc 주석 추가”
마이그레이션: “PropTypes를 TypeScript로 마이그레이션”
CI/CD: “테스트 실패 시 자동으로 이슈 생성 및 Slack 알림”

CLI 모드: 헤드리스 실행과 자동화 (2026년 신규)

2026년 주요 업데이트 중 하나는 Continue CLI의 대폭 개선입니다. 이제 Continue는 IDE 없이도 터미널에서 직접 사용할 수 있으며, CI/CD 파이프라인에 통합할 수 있습니다.

Headless 모드: 백그라운드 에이전트

Headless 모드는 사용자 인터랙션 없이 에이전트를 실행합니다. 이는 자동화된 워크플로우에 완벽합니다:

  
# PR마다 자동 코드 리뷰
continue agent run \
  --headless \
  --goal "Review all changed files for security issues" \
  --on-complete "post-to-github-pr"

# 야간 배치 작업
continue agent run \
  --headless \
  --schedule "0 2 * * *" \
  --goal "Update all outdated dependencies and create PR"

# 문서 자동 업데이트
continue agent run \
  --headless \
  --watch "src/**/*.ts" \
  --goal "Update API documentation when code changes"

TUI 모드: 터미널 UI

TUI (Text User Interface) 모드는 대화형 터미널 인터페이스를 제공합니다:

  
continue tui

# 실행되면 다음과 같은 인터페이스가 나타납니다:
┌─────────────────────────────────────────────────┐
│ Continue CLI v2.5.0                             │
│ Branch: main | Files changed: 3                 │
├─────────────────────────────────────────────────┤
│                                                 │
│ > Explain the changes in auth.ts                │
│                                                 │
│ 🤖 The auth.ts file now includes two-factor    │
│    authentication support. The main changes:    │
│    1. Added TOTP token generation               │
│    2. Updated login flow to verify 2FA          │
│    3. Added backup codes for recovery           │
│                                                 │
│ > _                                             │
│                                                 │
├─────────────────────────────────────────────────┤
│ Ctrl+C: Exit | Ctrl+P: Pause | /help: Commands │
└─────────────────────────────────────────────────┘

CI/CD 통합

Continue를 GitHub Actions, GitLab CI, Jenkins 등에 통합할 수 있습니다:

  
# .github/workflows/code-review.yml
name: AI Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Continue
        run: npm install -g @continuedev/cli
      
      - name: Configure Continue
        run: |
          mkdir -p ~/.continue
          echo "$CONTINUE_CONFIG" > ~/.continue/config.yaml
        env:
          CONTINUE_CONFIG: $
      
      - name: Run AI Review
        run: |
          continue agent run \
            --headless \
            --goal "Review PR for security, performance, and code quality" \
            --format markdown \
            > review.md
      
      - name: Post Review
        uses: actions/github-script@v6
        with:
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('review.md', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: review
            });

원격 에이전트 연결

--id 옵션으로 기존 원격 에이전트에 연결할 수 있습니다:

  
# 로컬에서 에이전트 시작
continue agent start --id "deploy-staging" --background

# 다른 터미널이나 머신에서 연결
continue agent connect --id "deploy-staging"

# 에이전트 상태 확인
continue agent status --id "deploy-staging"

# 에이전트 중지
continue agent stop --id "deploy-staging"

이는 장시간 실행되는 작업을 백그라운드에서 돌리고, 필요할 때만 연결하여 확인하는 워크플로우를 가능하게 합니다.

설정 및 확장성: 무한한 커스터마이제이션

Continue의 진정한 힘은 그 확장성에 있습니다. 거의 모든 측면을 설정 파일을 통해 커스터마이즈할 수 있으며, 플러그인 시스템을 통해 완전히 새로운 기능을 추가할 수 있습니다.

설정 파일 구조

Continue는 YAML과 JSON 두 형식을 모두 지원하지만, YAML이 권장됩니다 (가독성과 주석 지원):

  
# ~/.continue/config.yaml

# 모델 설정 - 역할별로 다른 모델 사용
models:
  # 채팅: 추론 능력이 뛰어난 모델
  - role: chat
    provider: anthropic
    model: claude-sonnet-4-5-20250929
    apiKey: ${ANTHROPIC_API_KEY}
    options:
      temperature: 0.3
      maxTokens: 4000
  
  # 자동완성: 빠르고 가벼운 로컬 모델
  - role: autocomplete
    provider: ollama
    model: deepseek-coder:1.3b
    options:
      temperature: 0.1
      numPredict: 50
  
  # 편집: 정확성이 중요한 모델
  - role: edit
    provider: openai
    model: gpt-4o
    apiKey: ${OPENAI_API_KEY}
    options:
      temperature: 0
  
  # 임베딩: 벡터 검색용
  - role: embed
    provider: ollama
    model: nomic-embed-text
  
  # 재순위: 검색 결과 정렬용
  - role: rerank
    provider: cohere
    model: rerank-english-v3.0
    apiKey: ${COHERE_API_KEY}

# 컨텍스트 제공자
contextProviders:
  # 코드 컨텍스트
  - name: code
    params:
      includeTests: true
      maxFileSize: 100000
  
  # 문서 컨텍스트
  - name: docs
    params:
      urls:
        - https://docs.continue.dev
        - https://react.dev/reference/react
      refreshInterval: 86400  # 24시간
  
  # Git 컨텍스트
  - name: git
    params:
      includeUntracked: false
  
  # 터미널 컨텍스트
  - name: terminal
    params:
      maxLines: 100
  
  # 문제 컨텍스트
  - name: problems
  
  # 폴더 구조
  - name: folder
    params:
      depth: 3
      ignore:
        - node_modules
        - .git
        - dist

# 시스템 메시지 - AI의 "성격"과 규칙
systemMessage: |
  You are an expert software engineer with deep knowledge of:
  - Modern TypeScript and React best practices
  - Clean architecture and SOLID principles
  - Test-driven development
  - Security best practices
  
  Always:
  - Write clean, readable, well-documented code
  - Follow the team's coding standards in .continue/rules/
  - Explain your reasoning when making architectural decisions
  - Suggest tests for new functionality
  
  Never:
  - Use deprecated APIs without explanation
  - Introduce security vulnerabilities
  - Write code without proper error handling

# 슬래시 커맨드
slashCommands:
  - name: test
    description: Generate unit tests
    prompt: |
      Write comprehensive unit tests for the selected code.
      Include:
      - Happy path tests
      - Edge cases
      - Error scenarios
      - Mock external dependencies
      Use Jest/Vitest syntax.
  
  - name: review
    description: Code review
    prompt: |
      Review the selected code for:
      1. Security vulnerabilities
      2. Performance issues
      3. Code quality and maintainability
      4. Compliance with @rules
      Provide specific, actionable feedback.
  
  - name: docs
    description: Generate documentation
    prompt: |
      Generate JSDoc/TSDoc comments for the selected code.
      Include:
      - Description of purpose
      - Parameter types and descriptions
      - Return value description
      - Usage examples
      - Notes about edge cases or limitations
  
  - name: refactor
    description: Suggest refactoring
    prompt: |
      Analyze the selected code and suggest refactoring opportunities:
      - Extract reusable functions/components
      - Improve naming
      - Reduce complexity
      - Apply design patterns where appropriate
      Explain the benefits of each suggestion.

# 규칙 디렉토리
rulesDirectory: .continue/rules/

# MCP 서버
mcpServers:
  - name: GitHub
    command: npx
    args:
      - "@modelcontextprotocol/server-github"
    env:
      GITHUB_TOKEN: ${GITHUB_TOKEN}
  
  - name: PostgreSQL
    command: npx
    args:
      - "mcp-postgres"
      - "--connection-string"
      - ${DATABASE_URL}
  
  - name: Custom Company API
    type: http
    url: https://api.mycompany.com/mcp
    headers:
      Authorization: Bearer ${COMPANY_API_TOKEN}

# 권한 설정
permissions:
  allow:
    - git_*
    - read_file
    - write_file: "src/**/*.ts"
  
  confirm:
    - delete_file
    - run_command: npm *
    - edit_file: "*.config.*"
  
  deny:
    - run_command: rm -rf *
    - run_command: sudo *
    - write_file: "**/*.env"

# 고급 옵션
advanced:
  # 자동완성 딜레이 (ms)
  autocompleteDelay: 300
  
  # 컨텍스트 윈도우 최대 토큰
  maxContextTokens: 100000
  
  # 병렬 도구 실행
  parallelToolCalls: true
  
  # 텔레메트리
  telemetry:
    enabled: false

규칙 시스템 (Rules)

.continue/rules/ 디렉토리는 Continue의 가장 강력한 기능 중 하나입니다. 이곳에 팀의 코딩 표준, 아키텍처 결정, 베스트 프랙티스를 문서화하면, Continue가 이를 자동으로 준수합니다:

.continue/rules/
├── coding-standards.md
├── architecture.md
├── security.md
├── testing.md
└── git-workflow.md

coding-standards.md 예시:

  
# Coding Standards

## TypeScript

- Always use strict mode
- Prefer `const` over `let`, never use `var`
- Use meaningful variable names (no single letters except in loops)
- All functions must have explicit return types
- Use object destructuring for multiple parameters

## React

- Use functional components, not class components
- Hooks must follow naming convention: `use*`
- Keep components small (<200 lines)
- Extract complex logic to custom hooks
- Use React.memo for expensive components

## Imports

- Group imports: external, internal, relative
- Sort alphabetically within each group
- Use absolute imports for `src/` directory

## Error Handling

- Never use empty catch blocks
- Always log errors with context
- Use custom error classes for domain-specific errors
- Return error objects, don't throw in async functions

## Comments

- Use JSDoc for public APIs
- Explain *why*, not *what*
- Keep comments up-to-date or remove them

이제 Continue는 코드를 생성할 때 이 규칙들을 자동으로 따릅니다:

User: 사용자 데이터 fetch하는 함수 만들어줘

Continue: [읽기: .continue/rules/coding-standards.md]
         [읽기: .continue/rules/architecture.md]

// src/api/user.ts

/**
 * Fetches user data from the API
 * @param userId - The unique identifier of the user
 * @returns Promise resolving to user data or error object
 */
export async function fetchUserData(
  userId: string
): Promise<{ data: User } | { error: Error }> {
  try {
    const response = await fetch(`/api/users/${userId}`);
    
    if (!response.ok) {
      const error = new ApiError(
        `Failed to fetch user ${userId}`,
        response.status
      );
      console.error('User fetch failed:', { userId, error });
      return { error };
    }
    
    const data = await response.json();
    return { data };
  } catch (error) {
    console.error('User fetch exception:', { userId, error });
    return { error: error as Error };
  }
}

[Note: Following team standards:
- TypeScript strict mode with explicit return type
- Error handling without throwing
- Logging with context
- JSDoc documentation]

다중 설정 프로파일

프로젝트나 상황에 따라 다른 설정을 사용할 수 있습니다:

  
# 개인 프로젝트용 (로컬 모델)
continue --config ~/.continue/config.personal.yaml

# 회사 프로젝트용 (엔터프라이즈 모델, MCP 서버)
continue --config ~/.continue/config.work.yaml

# 실험용 (최신 모델, 느슨한 권한)
continue --config ~/.continue/config.experimental.yaml

프로젝트별 설정도 가능합니다:

my-project/
├── .continue/
│   ├── config.yaml  # 프로젝트 특화 설정
│   ├── rules/       # 프로젝트 코딩 표준
│   └── mcpServers/  # 프로젝트 MCP 서버
└── src/

Continue는 다음 우선순위로 설정을 로드합니다:

프로젝트 내 .continue/config.yaml
홈 디렉토리 ~/.continue/config.yaml
기본 설정

기술 스택 및 구현 상세

Continue의 기술 스택은 현대적이고 검증된 기술들로 구성되어 있습니다.

언어 및 프레임워크

TypeScript 는 Continue 코드베이스의 핵심입니다. Core와 GUI는 100% TypeScript로 작성되었으며, 엄격한 타입 검사를 통해 런타임 에러를 최소화합니다. TypeScript의 선택 이유:

타입 안전성: 컴파일 타임에 대부분의 버그 발견
개발자 경험: 자동완성, 리팩토링 도구 지원
유지보수성: 코드베이스가 커져도 관리 가능
커뮤니티: VS Code 자체가 TypeScript로 작성됨

Node.js 20.19.0+ 는 Continue의 런타임 환경입니다. package.json의 engines 필드로 최소 버전을 강제하여, 최신 JavaScript 기능을 활용합니다.

React 18 은 GUI 레이어의 기반입니다. 함수형 컴포넌트와 Hooks를 적극 활용하며, Concurrent 기능으로 부드러운 UI를 제공합니다.

Redux Toolkit 은 상태 관리를 담당합니다. 전역 상태는 Redux Store에 저장되고, 컴포넌트는 useSelector와 useDispatch Hooks로 접근합니다. Redux DevTools를 통한 디버깅도 지원됩니다.

Kotlin + IntelliJ Platform SDK 는 JetBrains Extension의 언어입니다. Kotlin의 간결함과 IntelliJ Platform의 강력한 API를 활용하여, PyCharm, WebStorm, IntelliJ IDEA 등 모든 JetBrains IDE를 단일 코드베이스로 지원합니다.

빌드 및 개발 도구

Monorepo 구조 는 yarn workspaces로 관리됩니다:

continue/
├── core/              # 핵심 비즈니스 로직
│   ├── src/
│   ├── package.json
│   └── tsconfig.json
│
├── gui/               # React UI
│   ├── src/
│   ├── package.json
│   └── tsconfig.json
│
├── extensions/
│   ├── vscode/        # VS Code Extension
│   │   ├── src/
│   │   ├── package.json
│   │   └── tsconfig.json
│   │
│   └── jetbrains/     # JetBrains Plugin
│       ├── src/
│       ├── build.gradle.kts
│       └── plugin.xml
│
├── packages/
│   └── config-yaml/   # YAML 설정 파서
│
├── package.json       # 루트 package.json
└── yarn.lock

ESLint + Prettier가 코드 품질을 관리합니다. Husky pre-commit hooks를 통해 커밋 전 자동으로 린트와 포맷을 실행합니다:

  
// .husky/pre-commit
#!/bin/sh
. "$(dirname "$0")/_/husky.sh"

yarn lint-staged

lint-staged 설정:

  
{
  "lint-staged": {
    "*.{ts,tsx}": [
      "eslint --fix",
      "prettier --write"
    ],
    "*.{json,yaml,md}": [
      "prettier --write"
    ]
  }
}

릴리스 및 배포

Continue는 다중 채널 릴리스 전략을 사용합니다:

VS Code Extension:

Stable: VS Code Marketplace (주간 릴리스)
Beta: Open VSX Registry (일간 빌드)
Nightly: GitHub Releases (자동 빌드)

JetBrains Plugin:

Stable: JetBrains Marketplace (주간 릴리스)
EAP (Early Access): JetBrains EAP 채널 (주 2회)

CLI:

npm: npm install -g @continuedev/cli
Homebrew: brew install continue
Binary: GitHub Releases (Linux, macOS, Windows)

자동화된 CI/CD 파이프라인 (GitHub Actions):

  
# .github/workflows/release.yml (간소화)
name: Release

on:
  push:
    tags:
      - 'v*'

jobs:
  build-vscode:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
      - run: yarn install
      - run: yarn build:vscode
      - run: vsce publish
        env:
          VSCE_PAT: $
  
  build-jetbrains:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-java@v3
      - run: ./gradlew buildPlugin
      - run: ./gradlew publishPlugin
        env:
          PUBLISH_TOKEN: $
  
  build-cli:
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
    runs-on: $
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
      - run: yarn build:cli
      - run: yarn package:$
      - uses: actions/upload-artifact@v3

성능 최적화 및 확장성

Continue는 대규모 코드베이스에서도 원활하게 작동하도록 여러 최적화 기법을 사용합니다.

컨텍스트 압축

AI 모델의 컨텍스트 윈도우는 제한적이므로, Continue는 지능적으로 가장 관련성 높은 정보만 포함합니다:

1. AST 기반 코드 추출: 전체 파일이 아닌, 관련 함수/클래스만 추출 2. 임베딩 벡터 검색: 의미적으로 유사한 코드 조각 찾기 3. 재순위 지정 (Reranking): 검색 결과를 관련성 순으로 정렬 4. 점진적 로딩: 필요한 경우에만 추가 컨텍스트 로드

증분 인덱싱

Docs Provider와 Code Provider는 백그라운드에서 코드베이스를 인덱싱합니다:

  
// 개념적 구조
class IncrementalIndexer {
  private vectorDB: VectorDatabase;
  private fileWatcher: FileSystemWatcher;
  
  async initialize() {
    // 초기 인덱싱
    await this.indexAllFiles();
    
    // 파일 변경 감지
    this.fileWatcher.onDidChange(async (uri) => {
      await this.updateIndex(uri);
    });
  }
  
  async indexAllFiles() {
    const files = await this.getAllSourceFiles();
    for (const file of files) {
      const embedding = await this.embedFile(file);
      await this.vectorDB.upsert(file.uri, embedding);
    }
  }
  
  async updateIndex(uri: string) {
    const embedding = await this.embedFile(uri);
    await this.vectorDB.upsert(uri, embedding);
  }
}

캐싱 전략

모델 응답 캐싱: 동일한 입력에 대해 재계산하지 않음 임베딩 캐싱: 한 번 계산한 임베딩은 디스크에 저장 문서 캐싱: 크롤링한 문서는 로컬에 저장, 정기적으로 업데이트

병렬 처리

Agent 모드에서 여러 도구를 동시에 실행할 수 있습니다:

  
advanced:
  parallelToolCalls: true  # 기본값

예를 들어, “모든 테스트 파일에 주석 추가”라는 작업은:

테스트 파일 목록 가져오기
각 파일을 병렬로 처리 (최대 5개 동시)
결과 집계

이는 순차 처리 대비 5배 빠릅니다.

보안 및 프라이버시

Continue는 오픈소스이기 때문에, 보안과 프라이버시를 최우선으로 설계되었습니다.

완전 로컬 실행

Continue는 완전히 에어갭(air-gapped) 환경에서 실행될 수 있습니다:

  
models:
  - role: chat
    provider: ollama
    model: llama3.2
    # API 키 불필요, 외부 통신 없음
  
  - role: autocomplete
    provider: ollama
    model: deepseek-coder:1.3b

contextProviders:
  - name: code
  - name: folder
  - name: git
  # 모두 로컬 데이터만 사용

이 설정에서는 어떠한 데이터도 외부로 전송되지 않습니다. 규제가 엄격한 산업 (금융, 헬스케어, 국방)에서 필수적입니다.

환경 변수 보안

API 키와 같은 민감한 정보는 설정 파일에 직접 쓰지 않습니다:

  
# ❌ 절대 이렇게 하지 마세요
models:
  - role: chat
    provider: anthropic
    apiKey: sk-ant-api03-abc123...

# ✅ 올바른 방법
models:
  - role: chat
    provider: anthropic
    apiKey: ${ANTHROPIC_API_KEY}

Continue는 다음 순서로 환경 변수를 로드합니다:

시스템 환경 변수
.env 파일 (프로젝트 루트)
.env.local 파일 (gitignore에 추가)

텔레메트리 투명성

Continue는 사용 통계를 수집할 수 있지만, 완전히 선택사항이며 기본적으로 비활성화되어 있습니다:

  
advanced:
  telemetry:
    enabled: false  # 기본값

활성화하더라도 수집되는 정보는 제한적입니다:

사용된 기능 (Chat, Plan, Agent)
오류 발생 시 스택 트레이스 (개인정보 제거)
성능 메트릭 (응답 시간 등)

절대 수집되지 않는 것:

코드 내용
파일 이름
API 키
대화 내용

MCP 서버 격리

Docker 컨테이너로 실행되는 MCP 서버는 호스트 시스템으로부터 격리됩니다:

  
mcpServers:
  - name: Untrusted MCP
    type: docker
    image: third-party/mcp-server
    mounts:
      - /path/to/safe/directory:/data:ro  # 읽기 전용
    network: none  # 네트워크 접근 차단
    memory: 512m   # 메모리 제한
    cpus: 0.5      # CPU 제한

커뮤니티 및 생태계

Continue의 힘은 활발한 오픈소스 커뮤니티에서 나옵니다.

GitHub 리포지토리

30,000+ Stars: 개발자들의 높은 관심
활발한 기여: 매주 수십 개의 PR 머지
투명한 로드맵: GitHub Projects로 공개
빠른 이슈 대응: 평균 24시간 내 첫 응답

Discord 커뮤니티

Continue Discord 서버는 10,000+ 멤버를 보유하며:

실시간 지원 채널
기능 제안 및 투표
커스텀 MCP 서버 공유
베스트 프랙티스 토론

Continue Hub

Continue Hub (https://hub.continue.dev)는 커뮤니티 리소스 중앙 저장소입니다:

MCP 서버 마켓플레이스:

검증된 서버 목록
사용자 리뷰 및 평점
설치 가이드
소스 코드 링크

Skills 라이브러리:

재사용 가능한 워크플로우
프롬프트 템플릿
규칙 세트

설정 템플릿:

언어별 (Python, TypeScript, Go 등)
프레임워크별 (React, Django, Spring 등)
산업별 (핀테크, 헬스케어 등)

기업 지원

Continue는 무료 오픈소스이지만, Continue 팀은 기업을 위한 유료 지원도 제공합니다:

Solo Plan: $0/월

모든 기능
커뮤니티 지원

Teams Plan: $10/개발자/월

팀 협업 기능
공유 설정 및 규칙
우선 지원

Enterprise Plan: 커스텀 가격

온프레미스 배포
SSO/SAML 통합
SLA 보장
전담 지원팀
커스텀 MCP 서버 개발 지원

2026년 로드맵 및 미래 방향

Continue 팀은 2026년 로드맵을 공개했습니다:

Q1 2026 (완료)

✅ CLI 2.0: Headless 및 TUI 모드 ✅ MCP JSON 지원: 다른 도구와 호환성 ✅ GPT-5 지원: 최신 OpenAI 모델 ✅ Session Teleportation: 디바이스 간 세션 이동

Q2 2026 (진행 중)

🔄 네이티브 IDE 통합: VS Code/JetBrains API 깊은 통합 🔄 Multi-Agent Orchestration: 여러 에이전트 협업 🔄 Visual Debugging: 에이전트 실행 시각화 🔄 Mobile Apps: iOS/Android 네이티브 앱

Q3-Q4 2026 (계획)

📅 Voice Interface: 음성으로 코딩 📅 Real-time Collaboration: 팀원과 AI 세션 공유 📅 Custom Model Training: 프로젝트별 파인튜닝 📅 Blockchain Integration: 스마트 컨트랙트 개발

결론: Continue가 AI 코딩의 미래인 이유

Continue.dev는 단순한 AI 코딩 어시스턴트를 넘어, AI 개발 도구가 어떻게 설계되어야 하는지에 대한 청사진입니다. 그 핵심 원칙들은 다음과 같습니다:

개방성 (Openness): 오픈소스, 모델 독립적, 벤더 중립적. 개발자가 진정한 선택권을 가집니다.

확장성 (Extensibility): MCP 통합, 플러그인 시스템, 완전한 설정 가능성. 개발자가 도구를 자신에게 맞게 조정할 수 있습니다.

투명성 (Transparency): 모든 코드가 공개되어 있고, AI의 행동을 명확히 이해할 수 있으며, 텔레메트리는 선택사항입니다.

프라이버시 (Privacy): 완전 로컬 실행 가능, 데이터는 개발자의 것, 외부 전송 없음.

커뮤니티 (Community): 활발한 기여자들, 공개 로드맵, 투명한 의사결정.

이러한 원칙들이 Continue의 아키텍처 깊숙이 반영되어 있습니다. 3-Layer 분리 설계는 플랫폼 독립성을 보장하고, MCP 통합은 생태계 확장을 가능케 하며, 설정 시스템은 무한한 커스터마이제이션을 제공합니다.

2026년 현재, AI는 소프트웨어 개발의 필수 도구가 되었습니다. 하지만 도구는 개발자를 위해 존재해야 하며, 개발자가 도구에 종속되어서는 안 됩니다. Continue는 이 철학을 완벽하게 구현한 도구입니다. 개발자는 자신의 코드를, 자신의 AI를, 자신의 규칙으로 통제합니다.

Continue의 아키텍처를 이해하는 것은 단순히 하나의 도구를 배우는 것이 아닙니다. 이것은 미래의 AI 개발 도구가 어떻게 생겨야 하는지, 어떻게 설계되어야 하는지, 어떻게 커뮤니티와 함께 진화해야 하는지를 배우는 것입니다. 그리고 그 미래는 이미 여기 있습니다.

문서 작성 일자: 2026-01-31

참조 자료:

Continue.dev 공식 문서 (docs.continue.dev)
Continue GitHub 리포지토리 (github.com/continuedev/continue)
Model Context Protocol 사양 (modelcontextprotocol.io)
Continue 블로그 (blog.continue.dev)
DeepWiki Continue 분석
Medium 및 DEV Community 기술 문서들
Continue Hub (hub.continue.dev)

면책 조항: 본 문서는 2026년 1월 31일 기준 Continue.dev의 아키텍처를 분석한 것입니다. Continue는 활발하게 개발 중인 오픈소스 프로젝트이므로, 일부 내용은 시간이 지남에 따라 변경될 수 있습니다. 최신 정보는 공식 문서를 참조하시기 바랍니다.

AI, Agentic AI & Agentic Coding (20260131)