docsif 0.1.0__py3-none-any.whl

sif/mcp_server/transport.py

@@ -0,0 +1,221 @@
+"""MCP transport implementations."""
+
+import sys
+from abc import ABC, abstractmethod
+from typing import Any
+
+from sif.utils.logging import get_logger
+
+
+logger = get_logger(__name__)
+
+
+class Transport(ABC):
+    """Abstract base class for MCP transports."""
+
+    @abstractmethod
+    def start(self) -> None:
+        """Start the transport."""
+        ...
+
+    @abstractmethod
+    def stop(self) -> None:
+        """Stop the transport."""
+        ...
+
+    @abstractmethod
+    def send(self, message: dict[str, Any]) -> None:
+        """Send a message."""
+        ...
+
+    @abstractmethod
+    def receive(self) -> dict[str, Any] | None:
+        """Receive a message."""
+        ...
+
+
+class StdioTransport(Transport):
+    """stdio transport for MCP.
+
+    Uses standard input/output for communication.
+    Suitable for CLI integration and local tools.
+    """
+
+    def __init__(self) -> None:
+        """Initialize stdio transport."""
+        self._running = False
+
+    def start(self) -> None:
+        """Start stdio transport."""
+        logger.info("Starting stdio transport")
+        self._running = True
+
+        # Send initialization message
+        self.send(
+            {
+                "jsonrpc": "2.0",
+                "method": "initialize",
+                "params": {
+                    "protocolVersion": "1.0",
+                    "capabilities": {},
+                },
+            }
+        )
+
+        # Main loop
+        while self._running:
+            try:
+                message = self.receive()
+                if message:
+                    self._handle_message(message)
+            except EOFError:
+                break
+            except Exception as e:
+                logger.error(f"Error handling message: {e}")
+
+    def stop(self) -> None:
+        """Stop stdio transport."""
+        logger.info("Stopping stdio transport")
+        self._running = False
+
+    def send(self, message: dict[str, Any]) -> None:
+        """Send a message via stdout."""
+        import json  # noqa: PLC0415
+
+        json_str = json.dumps(message)
+        print(json_str, flush=True)
+
+    def receive(self) -> dict[str, Any] | None:
+        """Receive a message from stdin."""
+        import json  # noqa: PLC0415
+
+        try:
+            line = sys.stdin.readline()
+            if not line:
+                raise EOFError()
+            return json.loads(line)
+        except json.JSONDecodeError:
+            logger.error("Invalid JSON received")
+            return None
+
+    def _handle_message(self, message: dict[str, Any]) -> None:
+        """Handle an incoming message."""
+        method = message.get("method")
+
+        if method == "tools/list":
+            self._handle_tools_list(message)
+        elif method == "tools/call":
+            self._handle_tool_call(message)
+        elif method == "resources/list":
+            self._handle_resources_list(message)
+        else:
+            logger.warning(f"Unknown method: {method}")
+
+    def _handle_tools_list(self, message: dict[str, Any]) -> None:
+        """Handle tools/list request."""
+        self.send(
+            {
+                "jsonrpc": "2.0",
+                "id": message.get("id"),
+                "result": {
+                    "tools": [
+                        {
+                            "name": "search",
+                            "description": "Search indexed documents",
+                            "inputSchema": {
+                                "type": "object",
+                                "properties": {
+                                    "query": {"type": "string"},
+                                    "collection": {"type": "string"},
+                                },
+                                "required": ["query"],
+                            },
+                        },
+                    ],
+                },
+            }
+        )
+
+    def _handle_tool_call(self, message: dict[str, Any]) -> None:
+        """Handle tools/call request."""
+        params = message.get("params", {})
+        tool_name = params.get("name")
+
+        # Placeholder: actual implementation would call the tool
+        self.send(
+            {
+                "jsonrpc": "2.0",
+                "id": message.get("id"),
+                "result": {
+                    "content": [
+                        {"type": "text", "text": f"Tool '{tool_name}' called"},
+                    ],
+                },
+            }
+        )
+
+    def _handle_resources_list(self, message: dict[str, Any]) -> None:
+        """Handle resources/list request."""
+        self.send(
+            {
+                "jsonrpc": "2.0",
+                "id": message.get("id"),
+                "result": {
+                    "resources": [],
+                },
+            }
+        )
+
+
+class HTTPTransport(Transport):
+    """HTTP transport for MCP.
+
+    Uses HTTP/SSE for communication.
+    Suitable for remote access and web integration.
+    """
+
+    def __init__(
+        self,
+        host: str = "127.0.0.1",
+        port: int = 8080,
+    ) -> None:
+        """Initialize HTTP transport.
+
+        Args:
+            host: Server host
+            port: Server port
+        """
+        self._host = host
+        self._port = port
+        self._server: Any | None = None
+
+    def start(self) -> None:
+        """Start HTTP transport."""
+        import uvicorn  # noqa: PLC0415
+        from fastapi import FastAPI  # noqa: PLC0415
+
+        logger.info(f"Starting HTTP transport on {self._host}:{self._port}")
+
+        app = FastAPI(title="SIF MCP Server")
+
+        @app.get("/mcp/v1/tools")
+        async def list_tools() -> dict:
+            return {"tools": []}
+
+        @app.post("/mcp/v1/tools/{tool_name}")
+        async def call_tool(tool_name: str, params: dict) -> dict:
+            return {"result": f"Tool '{tool_name}' called with {params}"}
+
+        uvicorn.run(app, host=self._host, port=self._port)
+
+    def stop(self) -> None:
+        """Stop HTTP transport."""
+        logger.info("Stopping HTTP transport")
+
+    def send(self, message: dict[str, Any]) -> None:
+        """Send a message (not applicable for HTTP)."""
+        pass
+
+    def receive(self) -> dict[str, Any] | None:
+        """Receive a message (not applicable for HTTP)."""
+        return None

sif/models/__init__.py

@@ -0,0 +1,70 @@
+"""Pydantic models for data validation and serialization.
+
+This package contains all Pydantic models used for:
+- Request/response validation
+- Configuration management
+- Data serialization/deserialization
+- API schema definitions
+"""
+
+from sif.models.collection import (
+    CollectionCreate,
+    CollectionListResponse,
+    CollectionResponse,
+    CollectionUpdate,
+)
+from sif.models.context import (
+    ContextCreate,
+    ContextResponse,
+    ContextUpdate,
+)
+from sif.models.document import (
+    ChunkResponse,
+    DocumentCreate,
+    DocumentResponse,
+    DocumentSearchResult,
+    DocumentUpdate,
+)
+from sif.models.embedding import (
+    EmbeddingConfig,
+    EmbeddingModelInfo,
+    EmbeddingRequest,
+    EmbeddingResponse,
+)
+from sif.models.search import (
+    SearchOptions,
+    SearchQuery,
+    SearchResponse,
+    SearchResult,
+    SearchType,
+)
+
+
+__all__ = [
+    # Collection models
+    "CollectionCreate",
+    "CollectionUpdate",
+    "CollectionResponse",
+    "CollectionListResponse",
+    # Document models
+    "DocumentCreate",
+    "DocumentUpdate",
+    "DocumentResponse",
+    "DocumentSearchResult",
+    "ChunkResponse",
+    # Context models
+    "ContextCreate",
+    "ContextUpdate",
+    "ContextResponse",
+    # Search models
+    "SearchQuery",
+    "SearchResult",
+    "SearchResponse",
+    "SearchOptions",
+    "SearchType",
+    # Embedding models
+    "EmbeddingConfig",
+    "EmbeddingModelInfo",
+    "EmbeddingRequest",
+    "EmbeddingResponse",
+]

sif/models/collection.py

@@ -0,0 +1,51 @@
+"""Pydantic models for Collection operations."""
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class CollectionBase(BaseModel):
+    """Base model for Collection data."""
+
+    name: str = Field(..., min_length=1, max_length=255, description="Collection name")
+    description: str | None = Field(None, description="Collection description")
+
+
+class CollectionCreate(CollectionBase):
+    """Model for creating a new collection."""
+
+    paths: list[str] = Field(default_factory=list, description="Initial paths to include")
+    metadata: dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+class CollectionUpdate(BaseModel):
+    """Model for updating a collection."""
+
+    name: str | None = Field(None, min_length=1, max_length=255)
+    description: str | None = None
+    paths: list[str] | None = None
+    metadata: dict[str, Any] | None = None
+
+
+class CollectionResponse(CollectionBase):
+    """Model for collection response data."""
+
+    model_config = ConfigDict(from_attributes=True)
+
+    id: str = Field(..., description="Unique collection ID")
+    paths: list[str] = Field(default_factory=list, description="Indexed paths")
+    document_count: int = Field(0, ge=0, description="Number of documents")
+    chunk_count: int = Field(0, ge=0, description="Number of chunks")
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime = Field(..., description="Creation timestamp")
+    updated_at: datetime = Field(..., description="Last update timestamp")
+    last_indexed_at: datetime | None = Field(None, description="Last indexing timestamp")
+
+
+class CollectionListResponse(BaseModel):
+    """Model for listing collections."""
+
+    collections: list[CollectionResponse]
+    total: int = Field(..., ge=0)

sif/models/context.py

@@ -0,0 +1,45 @@
+"""Pydantic models for Context operations."""
+
+from datetime import datetime
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ContextType(str, Enum):
+    """Type of context."""
+
+    COLLECTION = "collection"
+    PATH = "path"
+    DOCUMENT = "document"
+    GLOBAL = "global"
+
+
+class ContextBase(BaseModel):
+    """Base model for Context data."""
+
+    content: str = Field(..., min_length=1, description="Context content")
+    context_type: ContextType = Field(..., description="Type of context")
+
+
+class ContextCreate(ContextBase):
+    """Model for creating a new context."""
+
+    target_id: str = Field(..., description="ID of the target (collection, path, etc.)")
+
+
+class ContextUpdate(BaseModel):
+    """Model for updating a context."""
+
+    content: str | None = Field(None, min_length=1)
+
+
+class ContextResponse(ContextBase):
+    """Model for context response data."""
+
+    model_config = ConfigDict(from_attributes=True)
+
+    id: str = Field(..., description="Unique context ID")
+    target_id: str = Field(..., description="ID of the target")
+    created_at: datetime = Field(...)
+    updated_at: datetime = Field(...)

sif/models/document.py

@@ -0,0 +1,76 @@
+"""Pydantic models for Document operations."""
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class DocumentMetadata(BaseModel):
+    """Document metadata extracted from frontmatter."""
+
+    title: str | None = None
+    author: str | None = None
+    date: datetime | None = None
+    tags: list[str] = Field(default_factory=list)
+    categories: list[str] = Field(default_factory=list)
+    custom: dict[str, Any] = Field(default_factory=dict)
+
+
+class DocumentBase(BaseModel):
+    """Base model for Document data."""
+
+    path: str = Field(..., description="File system path")
+    content: str = Field(..., description="Document content")
+
+
+class DocumentCreate(DocumentBase):
+    """Model for creating a new document."""
+
+    collection_id: str = Field(..., description="Parent collection ID")
+    metadata: DocumentMetadata = Field(default_factory=DocumentMetadata)
+
+
+class DocumentUpdate(BaseModel):
+    """Model for updating a document."""
+
+    content: str | None = None
+    metadata: DocumentMetadata | None = None
+
+
+class ChunkResponse(BaseModel):
+    """Model for document chunk response."""
+
+    model_config = ConfigDict(from_attributes=True)
+
+    id: str = Field(..., description="Chunk ID")
+    content: str = Field(..., description="Chunk content")
+    start_line: int = Field(..., ge=0)
+    end_line: int = Field(..., ge=0)
+    token_count: int = Field(..., ge=0)
+    embedding_id: str | None = None
+
+
+class DocumentResponse(DocumentBase):
+    """Model for document response data."""
+
+    model_config = ConfigDict(from_attributes=True)
+
+    id: str = Field(..., description="Unique document ID")
+    collection_id: str = Field(..., description="Parent collection ID")
+    metadata: DocumentMetadata = Field(default_factory=DocumentMetadata)
+    chunks: list[ChunkResponse] = Field(default_factory=list)
+    checksum: str = Field(..., description="Content checksum")
+    file_size: int = Field(..., ge=0)
+    created_at: datetime = Field(...)
+    updated_at: datetime = Field(...)
+    indexed_at: datetime | None = None
+
+
+class DocumentSearchResult(BaseModel):
+    """Model for document search result."""
+
+    document: DocumentResponse
+    score: float = Field(..., ge=0, le=1)
+    matched_chunks: list[ChunkResponse] = Field(default_factory=list)
+    highlights: list[str] = Field(default_factory=list)

sif/models/download.py

@@ -0,0 +1,208 @@
+"""Model download from ModelScope."""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+from sif.utils.logging import get_logger, is_quiet, suppress_output
+
+
+logger = get_logger(__name__)
+
+
+class ModelDownloader:
+    """Download models from ModelScope."""
+
+    DEFAULT_MODELS = {
+        "embedding": {
+            "model_id": "iic/gte_Qwen2-7B-instruct",
+            "description": "General text embedding model",
+        },
+        "reranker": {
+            "model_id": "iic/gte_Qwen2-7B-instruct",
+            "description": "Reranking model",
+        },
+        "query_expansion": {
+            "model_id": "qwen/Qwen2.5-0.5B-Instruct",
+            "description": "Query expansion model",
+        },
+    }
+
+    def __init__(self, cache_dir: str | Path | None = None) -> None:
+        """Initialize model downloader.
+
+        Args:
+            cache_dir: Directory to cache downloaded models
+        """
+        if cache_dir is None:
+            cache_dir = Path.home() / ".sif" / "models"
+        self.cache_dir = Path(cache_dir).expanduser().resolve()
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def download(
+        self,
+        model_id: str,
+        revision: str | None = None,
+        force: bool = False,
+    ) -> Path:
+        """Download a model from ModelScope.
+
+        Args:
+            model_id: ModelScope model ID (e.g., "iic/gte_Qwen2-7B-instruct")
+            revision: Model revision to download
+            force: Force re-download even if cached
+
+        Returns:
+            Path to downloaded model directory
+        """
+        try:
+            from modelscope import snapshot_download  # noqa: PLC0415
+        except ImportError:
+            logger.error("modelscope not installed. Install with: pip install modelscope")
+            raise
+
+        # Create cache subdirectory for this model
+        model_hash = hashlib.md5(model_id.encode()).hexdigest()[:8]
+        model_cache_dir = self.cache_dir / model_hash
+
+        # Check if already cached
+        if not force and model_cache_dir.exists():
+            # Check if model files exist
+            if any(model_cache_dir.iterdir()):
+                logger.info(f"Using cached model: {model_id}")
+                return model_cache_dir
+
+        # Download model
+        logger.info(f"Downloading model from ModelScope: {model_id}")
+
+        download_kwargs = {
+            "model_id": model_id,
+            "cache_dir": str(self.cache_dir),
+        }
+
+        if revision:
+            download_kwargs["revision"] = revision
+
+        try:
+            if is_quiet():
+                with suppress_output():
+                    model_path = snapshot_download(**download_kwargs)
+            else:
+                model_path = snapshot_download(**download_kwargs)
+            logger.info(f"Model downloaded to: {model_path}")
+            return Path(model_path)
+        except Exception as e:
+            logger.error(f"Failed to download model {model_id}: {e}")
+            raise
+
+    def download_embedding_model(
+        self,
+        model_id: str | None = None,
+        force: bool = False,
+    ) -> Path:
+        """Download embedding model.
+
+        Args:
+            model_id: ModelScope model ID (uses default if None)
+            force: Force re-download
+
+        Returns:
+            Path to downloaded model
+        """
+        if model_id is None:
+            model_id = self.DEFAULT_MODELS["embedding"]["model_id"]
+
+        return self.download(model_id, force=force)
+
+    def download_reranker_model(
+        self,
+        model_id: str | None = None,
+        force: bool = False,
+    ) -> Path:
+        """Download reranker model.
+
+        Args:
+            model_id: ModelScope model ID (uses default if None)
+            force: Force re-download
+
+        Returns:
+            Path to downloaded model
+        """
+        if model_id is None:
+            model_id = self.DEFAULT_MODELS["reranker"]["model_id"]
+
+        return self.download(model_id, force=force)
+
+    def download_query_expansion_model(
+        self,
+        model_id: str | None = None,
+        force: bool = False,
+    ) -> Path:
+        """Download query expansion model.
+
+        Args:
+            model_id: ModelScope model ID (uses default if None)
+            force: Force re-download
+
+        Returns:
+            Path to downloaded model
+        """
+        if model_id is None:
+            model_id = self.DEFAULT_MODELS["query_expansion"]["model_id"]
+
+        return self.download(model_id, force=force)
+
+    def get_model_info(self, model_id: str) -> dict:
+        """Get information about a model.
+
+        Args:
+            model_id: ModelScope model ID
+
+        Returns:
+            Model information dictionary
+        """
+        try:
+            from modelscope.hub.api import HubApi  # noqa: PLC0415
+
+            api = HubApi()
+            info = api.get_model_info(model_id)
+            return {
+                "model_id": model_id,
+                "name": info.get("Name", ""),
+                "description": info.get("Description", ""),
+                "tags": info.get("Tags", []),
+            }
+        except Exception as e:
+            logger.error(f"Failed to get model info for {model_id}: {e}")
+            return {"model_id": model_id, "error": str(e)}
+
+    def list_cached_models(self) -> list:
+        """List all cached models.
+
+        Returns:
+            List of cached model directories
+        """
+        if not self.cache_dir.exists():
+            return []
+
+        models = []
+        for item in self.cache_dir.iterdir():
+            if item.is_dir():
+                models.append(
+                    {
+                        "path": str(item),
+                        "name": item.name,
+                    }
+                )
+
+        return models
+
+    def clear_cache(self) -> None:
+        """Clear all cached models."""
+        import shutil  # noqa: PLC0415
+
+        if self.cache_dir.exists():
+            shutil.rmtree(self.cache_dir)
+            self.cache_dir.mkdir(parents=True, exist_ok=True)
+            logger.info("Model cache cleared")