source-context-mcp 0.1.dev1__tar.gz

source_context_mcp-0.1.dev1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.3
+Name: source-context-mcp
+Version: 0.1.dev1
+Summary: Local Model Context Protocol (MCP) server for Source Context code intelligence.
+Author: Le Ngoc Tu, Dang Huu Hieu, Huynh Phat Tai
+Author-email: Le Ngoc Tu <tuleaibk@gmail.com>, Dang Huu Hieu <danghuuhieu038@gmail.com>, Huynh Phat Tai <huynhphtai@gmail.com>
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: mcp[cli]>=2.0.0
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: pydantic-settings>=2.14.2
+Requires-Dist: tomli-w>=1.2.0
+Requires-Dist: typer>=0.27.0
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/TuLe142857/source-context
+Description-Content-Type: text/markdown
+
+# Readme for MCP Server

source_context_mcp-0.1.dev1/README.md

@@ -0,0 +1 @@
+# Readme for MCP Server

source_context_mcp-0.1.dev1/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "source-context-mcp"
+version = "0.1.dev1"
+description = "Local Model Context Protocol (MCP) server for Source Context code intelligence."
+readme = "README.md"
+authors = [
+    { name = "Le Ngoc Tu", email = "tuleaibk@gmail.com" },
+    { name = "Dang Huu Hieu", email = "danghuuhieu038@gmail.com" },
+    { name = "Huynh Phat Tai", email = "huynhphtai@gmail.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "httpx>=0.28.1",
+    "mcp[cli]>=2.0.0",
+    "pydantic>=2.13.4",
+    "pydantic-settings>=2.14.2",
+    "tomli-w>=1.2.0",
+    "typer>=0.27.0",
+]
+
+
+
+[project.urls]
+Repository = "https://github.com/TuLe142857/source-context"
+
+[project.scripts]
+source-context-mcp = "source_context_mcp:run"
+
+[build-system]
+requires = ["uv_build>=0.11.21,<0.12.0"]
+build-backend = "uv_build"
+
+[tool.ruff]
+extend = "../pyproject.toml"
+
+[tool.mypy]
+python_version = "3.12"
+explicit_package_bases = true
+mypy_path = ["src"]
+check_untyped_defs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+no_implicit_optional = true
+warn_return_any = true
+warn_unused_ignores = true
+warn_redundant_casts = true
+warn_unreachable = true
+show_error_codes = true

source_context_mcp-0.1.dev1/src/source_context_mcp/__init__.py

@@ -0,0 +1,5 @@
+from .cli import cli
+
+
+def run():
+    cli()

source_context_mcp-0.1.dev1/src/source_context_mcp/__main__.py

@@ -0,0 +1,4 @@
+from .cli import cli
+
+if __name__ == "__main__":
+    cli()

source_context_mcp-0.1.dev1/src/source_context_mcp/cli.py

@@ -0,0 +1,49 @@
+import typer
+
+from .core.settings import CONFIG_FILE, get_settings, get_settings_with_overrides, write_settings
+from .server import create_server
+
+cli = typer.Typer()
+
+
+@cli.command(name="run", help="Run the MCP server")
+def run(
+    server_url_override: str | None = typer.Option(
+        None, "--server-url", help="Server url to override for this session"
+    ),
+    pat_override: str | None = typer.Option(None, "--token", help="Token to override for this session"),
+    workspace_id: int | None = typer.Option(
+        None, "--workspace-id", help="Default workspace id to override for this session"
+    ),
+):
+    server = create_server(
+        base_url_override=server_url_override,
+        pat_override=pat_override,
+        workspace_id_override=workspace_id,
+    )
+    server.run("stdio")
+
+
+@cli.command(name="config", help="Configure the MCP server")
+def config(
+    server_url: str | None = typer.Option(None, "--server-url", help="Server URL"),
+    token: str | None = typer.Option(None, "--token", help="Personal Access Token"),
+    default_workspace_id: int | None = typer.Option(None, "--workspace-id", help="Default workspace id"),
+):
+    settings = get_settings_with_overrides(
+        server_url_override=server_url,
+        pat_override=token,
+        default_workspace_id_override=default_workspace_id,
+    )
+    write_settings(settings)
+    typer.echo(f"Config saved to {CONFIG_FILE}")
+
+
+@cli.command(name="show-config", help="Show the MCP server's configuration")
+def show_config():
+    settings = get_settings()
+    settings_json = settings.model_dump_json(indent=2)
+
+    typer.echo(f"Configuration file: {CONFIG_FILE}")
+    typer.echo("Note: Secret value will be display as ***")
+    typer.echo(settings_json)

source_context_mcp-0.1.dev1/src/source_context_mcp/core/__init__.py

@@ -0,0 +1,9 @@
+from .api_client import ApiClient as ApiClient
+from .api_client import ApiResponse as ApiResponse
+from .context import AppContext as AppContext
+from .dependencies import ApiClientDep as ApiClientDep
+from .settings import CONFIG_FILE as CONFIG_FILE
+from .settings import Settings as Settings
+from .settings import get_settings as get_settings
+from .settings import get_settings_with_overrides as get_settings_with_overrides
+from .settings import write_settings as write_settings

source_context_mcp-0.1.dev1/src/source_context_mcp/core/api_client.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal, overload
+
+import httpx
+from pydantic import TypeAdapter, ValidationError
+
+
+@dataclass
+class ApiResponse[T]:
+    success: bool
+    status_code: int
+    data: T | None
+    error_code: str | None
+    message: str | None
+
+    @staticmethod
+    def ok(data: T | None, message: str | None = None, status_code: int = 200) -> ApiResponse[T]:
+        return ApiResponse(
+            success=True,
+            status_code=status_code,
+            data=data,
+            message=message,
+            error_code=None,
+        )
+
+    @staticmethod
+    def error(status_code: int, error_code: str, message: str | None = None) -> ApiResponse:
+        return ApiResponse(
+            success=False,
+            data=None,
+            status_code=status_code,
+            error_code=error_code,
+            message=message,
+        )
+
+
+class ApiClient:
+    def __init__(self, base_url: str, token: str, max_retry: int = 1):
+        """
+        Args:
+            base_url: server url
+            token: personal access token
+        """
+        self.server_url = base_url
+        self.token = token
+        self.max_retry = max_retry
+        self.async_client = httpx.AsyncClient(
+            base_url=self.server_url,
+            headers={
+                "Authorization": f"Bearer {self.token}",
+                "Accept": "application/json",
+            }
+            if len(token) > 0
+            else None,
+        )
+
+    async def close(self):
+        if self.async_client is not None:
+            await self.async_client.aclose()
+
+    def _parse_data(self, data: Any, response_model: type) -> Any:
+        """
+        Raises:
+            ValidationError
+        """
+        adapter = TypeAdapter(response_model)
+        return adapter.validate_python(data)
+
+    async def _request(
+        self,
+        method: Literal["GET", "PUT", "POST", "PATCH", "DELETE"],
+        path: str,
+        response_model: type | None = None,
+        **kwargs,
+    ) -> ApiResponse[Any]:
+        for attempt in range(self.max_retry):
+            try:
+                resp = await self.async_client.request(method, path, **kwargs)
+                resp.raise_for_status()
+
+                try:
+                    raw_data = resp.json()
+                    if isinstance(raw_data, dict) and "data" in raw_data:
+                        raw_data = raw_data["data"]
+                except ValueError:
+                    raw_data = resp.text
+
+                if response_model is not None:
+                    try:
+                        parsed_data = self._parse_data(raw_data, response_model)
+                        return ApiResponse.ok(data=parsed_data)
+                    except ValidationError as e:
+                        return ApiResponse.error(0, str(e))
+                else:
+                    return ApiResponse.ok(data=raw_data)
+
+            except httpx.TimeoutException:
+                if attempt < self.max_retry - 1:
+                    continue
+                return ApiResponse.error(
+                    status_code=0,
+                    error_code="REQUEST_TIMEOUT",
+                )
+
+            except httpx.ConnectError:
+                if attempt < self.max_retry - 1:
+                    continue
+                return ApiResponse.error(
+                    status_code=0,
+                    error_code="CONNECTION_ERROR",
+                )
+
+            except httpx.HTTPError as exc:
+                return ApiResponse.error(0, str(exc))
+
+        return ApiResponse.error(0, "UNKNOW_ERROR", f"Request failed after {self.max_retry} attempts")
+
+    @overload
+    async def get(self, path: str, params: dict | None = None) -> ApiResponse[Any]: ...
+    @overload
+    async def get[M](self, path: str, params: dict | None = None, *, response_model: type[M]) -> ApiResponse[M]: ...
+    async def get[M](self, path: str, params: dict | None = None, *, response_model: type[M] | None = None):
+        return await self._request("GET", path, response_model=response_model, params=params)
+
+    @overload
+    async def post(self, path: str, json: dict | None = None) -> ApiResponse[Any]: ...
+    @overload
+    async def post[M](self, path: str, json: dict | None = None, *, response_model: type[M]) -> ApiResponse[M]: ...
+    async def post[M](self, path: str, json: dict | None = None, *, response_model: type[M] | None = None):
+        return await self._request("POST", path, response_model=response_model, json=json)
+
+    @overload
+    async def put(self, path: str, json: dict | None = None) -> ApiResponse[Any]: ...
+    @overload
+    async def put[M](self, path: str, json: dict | None = None, *, response_model: type[M]) -> ApiResponse[M]: ...
+    async def put[M](self, path: str, json: dict | None = None, *, response_model: type[M] | None = None):
+        return await self._request("PUT", path, response_model=response_model, json=json)
+
+    @overload
+    async def patch(self, path: str, json: dict | None = None) -> ApiResponse[Any]: ...
+    @overload
+    async def patch[M](self, path: str, json: dict | None = None, *, response_model: type[M]) -> ApiResponse[M]: ...
+    async def patch[M](self, path: str, json: dict | None = None, *, response_model: type[M] | None = None):
+        return await self._request("PATCH", path, response_model=response_model, json=json)
+
+    @overload
+    async def delete(self, path: str) -> ApiResponse[Any]: ...
+    @overload
+    async def delete[M](self, path: str, *, response_model: type[M]) -> ApiResponse[M]: ...
+    async def delete[M](self, path: str, *, response_model: type[M] | None = None):
+        return await self._request("DELETE", path, response_model=response_model)

source_context_mcp-0.1.dev1/src/source_context_mcp/core/context.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+from .api_client import ApiClient
+from .settings import Settings
+
+
+@dataclass
+class AppContext:
+    api_client: ApiClient
+    settings: Settings

source_context_mcp-0.1.dev1/src/source_context_mcp/core/dependencies.py

@@ -0,0 +1,13 @@
+from typing import Annotated
+
+from mcp.server.mcpserver import Context, Resolve
+
+from source_context_mcp.core import ApiClient, AppContext
+
+
+def get_api_client(ctx: Context[AppContext]) -> ApiClient:
+    app_context: AppContext = ctx.request_context.lifespan_context
+    return app_context.api_client
+
+
+ApiClientDep = Annotated[ApiClient, Resolve(get_api_client)]

source_context_mcp-0.1.dev1/src/source_context_mcp/core/settings.py

@@ -0,0 +1,91 @@
+from functools import lru_cache
+from pathlib import Path
+
+import tomli_w
+from pydantic import SecretStr
+from pydantic_settings import BaseSettings, PydanticBaseSettingsSource, SettingsConfigDict, TomlConfigSettingsSource
+
+CONFIG_DIR = Path.home() / ".source_context_mcp"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        toml_file=str(CONFIG_FILE),
+    )
+
+    SERVER_URL: str = "default"
+    """Server URL. Include prefix. Example: http://localhost:8000/mcp/v1"""
+
+    PAT: SecretStr = SecretStr("Default")
+    """Personal access token"""
+
+    DEFAULT_WORKSPACE_ID: int = 1
+    """Default Workspace ID"""
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ):
+        return (
+            init_settings,
+            TomlConfigSettingsSource(settings_cls),
+        )
+
+
+@lru_cache
+def get_settings() -> Settings:
+    """
+    Get default settings.
+        - See ``get_settings_with_overrides`` to see how to get settings with overrides values.
+    Returns:
+
+    """
+    return Settings()
+
+
+def get_settings_with_overrides(
+    server_url_override: str | None = None,
+    pat_override: SecretStr | str | None = None,
+    default_workspace_id_override: int | None = None,
+) -> Settings:
+    """
+    Get settings with overrides values. Any None value will be ignored.
+        - This method does not change value of ``get_settings``
+        - This method does not change default settings in config file.
+    """
+
+    fields_overrides = {}
+    if server_url_override is not None:
+        fields_overrides["SERVER_URL"] = server_url_override
+    if pat_override is not None:
+        fields_overrides["PAT"] = pat_override if isinstance(pat_override, SecretStr) else SecretStr(pat_override)
+    if default_workspace_id_override is not None:
+        fields_overrides["DEFAULT_WORKSPACE_ID"] = default_workspace_id_override
+
+    # Any unprovided fields will be read from config file
+    return Settings(**fields_overrides)
+
+
+def write_settings(settings: Settings):
+    """
+    Write settings to config file. Reset cache of ``get_settings()``
+    """
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+    data = {
+        "SERVER_URL": settings.SERVER_URL,
+        "PAT": settings.PAT.get_secret_value(),
+        "DEFAULT_WORKSPACE_ID": settings.DEFAULT_WORKSPACE_ID,
+    }
+
+    with CONFIG_FILE.open("wb") as f:
+        tomli_w.dump(data, f)
+
+    # clear old cache
+    get_settings.cache_clear()

source_context_mcp-0.1.dev1/src/source_context_mcp/server.py

@@ -0,0 +1,51 @@
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+
+from mcp.server import MCPServer
+
+from source_context_mcp.core import ApiClient, AppContext, get_settings_with_overrides
+from source_context_mcp.tools import register_tools
+
+
+def make_life_span(
+    base_url_override: str | None = None, pat_override: str | None = None, workspace_id_override: int | None = None
+):
+    @asynccontextmanager
+    async def server_lifespan(app: MCPServer) -> AsyncIterator[AppContext]:
+        settings = get_settings_with_overrides(
+            server_url_override=base_url_override,
+            pat_override=pat_override,
+            default_workspace_id_override=workspace_id_override,
+        )
+
+        yield AppContext(
+            api_client=ApiClient(base_url=settings.SERVER_URL, token=settings.PAT.get_secret_value()), settings=settings
+        )
+
+    return server_lifespan
+
+
+def create_server(
+    base_url_override: str | None = None, pat_override: str | None = None, workspace_id_override: int | None = None
+) -> MCPServer:
+    """
+    Create an MCPServer instance.
+    Returns:
+        MCPServer instance.
+    """
+
+    life_span = make_life_span(
+        base_url_override=base_url_override, pat_override=pat_override, workspace_id_override=workspace_id_override
+    )
+
+    server = MCPServer(
+        name="SourceContextMCP",
+        lifespan=life_span,
+    )
+
+    register_tools(server)
+
+    return server
+
+
+mcp = create_server()

source_context_mcp-0.1.dev1/src/source_context_mcp/tools/__init__.py

@@ -0,0 +1,19 @@
+from mcp.server import MCPServer
+
+from .base import register_tools as register_base_tools
+from .debug import register_tools as register_debug_tools
+from .graph import register_tools as register_graph_tools
+from .vector import register_tools as register_vector_tools
+
+
+def register_tools(mcp: MCPServer) -> None:
+    """
+    Registry tools for MCPServer.
+    Args:
+        mcp: instance of MCPServer
+    """
+    register_debug_tools(mcp)
+
+    register_base_tools(mcp)
+    register_graph_tools(mcp)
+    register_vector_tools(mcp)

source_context_mcp-0.1.dev1/src/source_context_mcp/tools/base.py

@@ -0,0 +1,41 @@
+from typing import Any
+
+from mcp.server import MCPServer
+
+from source_context_mcp.core import ApiClientDep
+
+
+def register_tools(mcp: MCPServer) -> None:
+    """
+    Register bases tools:
+        - list user's available workspaces
+        - list repos in workspace
+        - list branches in repo
+        - list projects in branch
+
+    Args:
+        mcp: MCPServer instance
+    """
+
+    @mcp.tool(description="List all available workspaces that current user can access")
+    async def list_workspaces(client: ApiClientDep) -> Any:
+        res = await client.get("/general/workspaces", response_model=list)
+        return res.data
+
+    @mcp.tool(description="List all available repositories in workspace")
+    async def list_repositories(
+        client: ApiClientDep,
+        workspace_id: int,
+    ) -> Any:
+        res = await client.post("/general/repositories", {"workspace_id": workspace_id})
+        return res.data
+
+    @mcp.tool(description="List all available branches in specified repository.")
+    async def list_branches(client: ApiClientDep, project_id: int) -> Any:
+        """This tool is not implemented yet"""
+        return ["This tool is not implemented yet"]
+
+    @mcp.tool(description="List all available projects in specific branch.")
+    def list_projects(client: ApiClientDep, branch_id: int) -> Any:
+        """This tool is not implemented yet"""
+        return ["This tool is not implemented yet"]

source_context_mcp-0.1.dev1/src/source_context_mcp/tools/debug.py

@@ -0,0 +1,11 @@
+from mcp.server import MCPServer
+from mcp.server.mcpserver import Context
+
+from source_context_mcp.core import AppContext, Settings
+
+
+def register_tools(mcp: MCPServer):
+    @mcp.tool(description="This tool for development env only. Show all current config. Read source code to see more")
+    def debug(ctx: Context[AppContext]) -> Settings:
+        app_context: AppContext = ctx.request_context.lifespan_context
+        return app_context.settings

source_context_mcp-0.1.dev1/src/source_context_mcp/tools/graph.py

@@ -0,0 +1,38 @@
+from typing import Any
+
+from mcp.server import MCPServer
+
+from source_context_mcp.core import ApiClientDep
+
+
+def register_tools(mcp: MCPServer) -> None:
+    """
+    Registers all the graph tools.
+    Args:
+        mcp: MCPServer instance
+    """
+
+    @mcp.tool(description="List all files in specified project.")
+    async def list_files_in_project(client: ApiClientDep, project_id: str) -> Any:
+        res = await client.get(f"/graph/projects/{project_id}/files")
+        return res.data
+
+    @mcp.tool(description="Inspect file structure(classes and methods")
+    async def get_file_structure(client: ApiClientDep, file_id: str) -> Any:
+        res = await client.get(f"/graph/files/{file_id}/structures")
+        return res.data
+
+    @mcp.tool(description="Read file content.")
+    async def get_file_content(client: ApiClientDep, file_id: str) -> Any:
+        res = await client.get(f"/graph/files/{file_id}/content")
+        return res.data
+
+    @mcp.tool(description="Find all nodes that call/reference to the specified node.")
+    async def find_node_usages(client: ApiClientDep, node_id: str) -> Any:
+        res = await client.get(f"/graph/nodes/{node_id}/usages")
+        return res.data
+
+    @mcp.tool(description="Find all nodes(or its children) that the specified node is calling or reference to.")
+    async def find_node_callees(client: ApiClientDep, node_id: str) -> Any:
+        res = await client.get(f"/graph/nodes/{node_id}/callees")
+        return res.data

source_context_mcp-0.1.dev1/src/source_context_mcp/tools/vector.py

@@ -0,0 +1,37 @@
+from typing import Any
+
+from mcp.server import MCPServer
+
+from source_context_mcp.core import ApiClientDep
+
+
+def register_tools(mcp: MCPServer) -> None:
+    """
+    Registers all the vector tools.
+    Args:
+        mcp: MCP server instance
+    """
+
+    @mcp.tool()
+    async def search_in_workspace(client: ApiClientDep, query: str, workspace_id: int, top_k: int = 5) -> Any:
+        req_body = {
+            "query": query,
+            "top_k": top_k,
+        }
+
+        res = await client.post(f"/vector/search/{workspace_id}", req_body)
+
+        return res.data
+
+    @mcp.tool()
+    async def search_in_repo_and_branch(
+        client: ApiClientDep, repository_id: int, branch_name: str, query: str, top_k: int = 5
+    ) -> Any:
+        req_body = {
+            "query": query,
+            "top_k": top_k,
+        }
+
+        res = await client.post(f"/vector/search/{repository_id}/{branch_name}", req_body)
+
+        return res.data