updated doc strings

docforge/renderers/mcp_renderer.py

@@ -7,18 +7,25 @@ from docforge.models import Project, Module, DocObject
 
 class MCPRenderer:
     """
-    Renderer that emits MCP-native JSON resources from docforge models.
+    Renderer that generates MCP-compatible documentation resources.
+
+    This renderer converts doc-forge project models into structured JSON
+    resources suitable for consumption by systems implementing the Model
+    Context Protocol (MCP).
     """
 
     name = "mcp"
 
     def generate_sources(self, project: Project, out_dir: Path) -> None:
         """
-        Generate MCP-compatible JSON resources and navigation for the project.
+        Generate MCP documentation resources for a project.
+
+        The renderer serializes each module into a JSON resource and produces
+        supporting metadata files such as ``nav.json`` and ``index.json``.
 
         Args:
-            project: The project model to render.
-            out_dir: Target directory for the generated JSON files.
+            project: Documentation project model to render.
+            out_dir: Directory where MCP resources will be written.
         """
         modules_dir = out_dir / "modules"
         modules_dir.mkdir(parents=True, exist_ok=True)
@@ -54,11 +61,11 @@ class MCPRenderer:
 
     def _write_module(self, module: Module, modules_dir: Path) -> None:
         """
-        Serialize a module into an MCP JSON resource on disk.
+        Serialize a module into an MCP resource file.
 
         Args:
-            module: The module instance to serialize.
-            modules_dir: The directory where the module JSON file should be written.
+            module: Module instance to serialize.
+            modules_dir: Directory where module JSON files are stored.
         """
         payload = {
             "module": module.path,
@@ -71,13 +78,13 @@ class MCPRenderer:
 
     def _render_module(self, module: Module) -> Dict:
         """
-        Render a Module into MCP-friendly structured data.
+        Convert a Module model into MCP-compatible structured data.
 
         Args:
-            module: The module instance to render.
+            module: Module instance to convert.
 
         Returns:
-            A dictionary following the MCP documentation resource schema.
+            Dictionary representing the module and its documented objects.
         """
         data: Dict = {
             "path": module.path,
@@ -92,13 +99,13 @@ class MCPRenderer:
 
     def _render_object(self, obj: DocObject) -> Dict:
         """
-        Recursively render a DocObject into structured MCP data.
+        Recursively convert a DocObject into structured MCP data.
 
         Args:
-            obj: The documented object (class, func, etc.) to render.
+            obj: Documentation object to convert.
 
         Returns:
-            A dictionary representing the object and its members.
+            Dictionary describing the object and any nested members.
         """
         data: Dict = {
             "name": obj.name,
@@ -119,4 +126,13 @@ class MCPRenderer:
 
     @staticmethod
     def _json(data: Dict) -> str:
+        """
+        Serialize data to formatted JSON.
+
+        Args:
+            data: Dictionary to serialize.
+
+        Returns:
+            JSON string formatted with indentation and UTF-8 compatibility.
+        """
         return json.dumps(data, indent=2, ensure_ascii=False)