fix

docs/claude-code-inception-methods.md

@@ -0,0 +1,246 @@
+# Claude CodeでClaude Code的環境を作る方法
+
+Claude Code**で**Claude Code**のような**ことを実現する様々なアプローチをご紹介！
+
+## 🎯 方法1: MCP Server経由でローカルLLMに委譲
+
+### claude-code-mcp を使用
+```bash
+# Claude Code MCPサーバーのセットアップ
+git clone https://github.com/steipete/claude-code-mcp
+cd claude-code-mcp
+
+# Claude Codeをローカルで呼び出すMCPサーバーとして動作
+npm install
+npm start
+```
+
+**仕組み：**
+- Claude Code → MCP Server → ローカルLLM → 結果を返す
+- Claude Codeを全権限バイパス（--dangerously-skip-permissions）で実行
+- Agent in Agent 構造の実現
+
+## 🎯 方法2: Claude Desktop + Custom MCP Server
+
+### カスタムMCPサーバーでローカルLLM統合
+```python
+# custom_llm_mcp_server.py
+import asyncio
+import json
+from mcp.server import Server
+from mcp.types import Tool, TextContent
+import requests
+
+app = Server("local-llm-mcp")
+
+@app.tool("run_local_llm")
+async def run_local_llm(prompt: str, model: str = "qwen2.5-coder:14b") -> str:
+    """ローカルLLMでコード生成・分析を実行"""
+    response = requests.post("http://localhost:11434/api/generate", json={
+        "model": model,
+        "prompt": prompt,
+        "stream": False
+    })
+    return response.json()["response"]
+
+@app.tool("execute_code")
+async def execute_code(code: str, language: str = "python") -> str:
+    """生成されたコードを実行"""
+    # セキュアな実行環境でコード実行
+    # Docker containerやsandbox環境推奨
+    pass
+
+if __name__ == "__main__":
+    asyncio.run(app.run())
+```
+
+### Claude Desktop設定
+```json
+{
+  "mcpServers": {
+    "local-llm": {
+      "command": "python",
+      "args": ["custom_llm_mcp_server.py"]
+    }
+  }
+}
+```
+
+## 🎯 方法3: VS Code拡張 + MCP統合
+
+### VS Code設定でClaude Code風環境
+```json
+// settings.json
+{
+  "mcp.servers": {
+    "claude-code-local": {
+      "command": ["python", "claude_code_local.py"],
+      "args": ["--model", "qwen2.5-coder:14b"]
+    }
+  }
+}
+```
+
+VS Codeは両方の構成（ローカル/リモート）をサポートしているから、柔軟に設定できるよ〜
+
+## 🎯 方法4: API Gateway パターン
+
+### Claude Code → API Gateway → ローカルLLM
+```python
+# api_gateway.py
+from fastapi import FastAPI
+import requests
+
+app = FastAPI()
+
+@app.post("/v1/chat/completions")
+async def proxy_to_local_llm(request: dict):
+    """OpenAI API互換エンドポイント"""
+    # Claude Code → この API → Ollama
+    ollama_response = requests.post(
+        "http://localhost:11434/api/chat",
+        json={
+            "model": "qwen2.5-coder:14b",
+            "messages": request["messages"]
+        }
+    )
+    
+    # OpenAI API形式で返却
+    return {
+        "choices": [{
+            "message": {"content": ollama_response.json()["message"]["content"]}
+        }]
+    }
+```
+
+### Claude Code設定
+```bash
+# 環境変数でローカルAPIを指定
+export ANTHROPIC_API_KEY="dummy"
+export ANTHROPIC_BASE_URL="http://localhost:8000/v1"
+claude code --api-base http://localhost:8000
+```
+
+## 🎯 方法5: Docker Compose 統合環境
+
+### docker-compose.yml
+```yaml
+version: '3.8'
+services:
+  ollama:
+    image: ollama/ollama:latest
+    ports:
+      - "11434:11434"
+    volumes:
+      - ollama_data:/root/.ollama
+    
+  mcp-server:
+    build: ./mcp-server
+    ports:
+      - "3000:3000"
+    depends_on:
+      - ollama
+    environment:
+      - OLLAMA_URL=http://ollama:11434
+      
+  claude-desktop:
+    image: claude-desktop:latest
+    volumes:
+      - ./config:/app/config
+    environment:
+      - MCP_SERVER_URL=http://mcp-server:3000
+
+volumes:
+  ollama_data:
+```
+
+DockerはMCPサーバーの展開と管理を簡素化し、分離とポータビリティを提供
+
+## 🎯 方法6: 簡易プロキシスクリプト
+
+### claude_to_local.py
+```python
+#!/usr/bin/env python3
+import subprocess
+import sys
+import json
+
+def claude_code_wrapper():
+    """Claude CodeコマンドをインターセプトしてローカルLLMに転送"""
+    
+    # Claude Codeの引数を取得
+    args = sys.argv[1:]
+    prompt = " ".join(args)
+    
+    # ローカルLLMで処理
+    result = subprocess.run([
+        "ollama", "run", "qwen2.5-coder:14b", prompt
+    ], capture_output=True, text=True)
+    
+    # 結果を整形してClaude Code風に出力
+    print("🤖 Local Claude Code (Powered by Qwen2.5-Coder)")
+    print("=" * 50)
+    print(result.stdout)
+    
+    # 必要に応じてファイル操作も実行
+    if "--write" in args:
+        # ファイル書き込み処理
+        pass
+
+if __name__ == "__main__":
+    claude_code_wrapper()
+```
+
+### エイリアス設定
+```bash
+# .bashrc または .zshrc
+alias claude-code="python claude_to_local.py"
+```
+
+## 🎯 方法7: Aider + Claude Code 統合
+
+### 設定方法
+```bash
+# Aiderでローカルモデル使用
+aider --model ollama/qwen2.5-coder:14b
+
+# Claude Codeから呼び出し
+claude code "Run aider with local model to implement feature X"
+```
+
+## 💡 どの方法がおすすめ？
+
+### 用途別推奨：
+
+1. **🔧 開発効率重視**: MCP Server方式（方法1,2）
+2. **🏠 統合環境**: Docker Compose（方法5）
+3. **⚡ 簡単設置**: プロキシスクリプト（方法6）
+4. **🎨 カスタマイズ**: API Gateway（方法4）
+
+## 🚀 実装のコツ
+
+### セキュリティ考慮
+- サンドボックス環境でコード実行
+- ファイルアクセス権限の制限
+- API キーの適切な管理
+
+### パフォーマンス最適化
+- ローカルLLMのGPU使用確認
+- MCP サーバーのキャッシュ機能
+- 並列処理の活用
+
+### デバッグ方法
+```bash
+# MCP サーバーのログ確認
+tail -f ~/.config/claude-desktop/logs/mcp.log
+
+# Ollama の動作確認
+ollama ps
+curl http://localhost:11434/api/tags
+```
+
+## 🎉 まとめ
+
+Claude CodeでClaude Code的な環境を作るには、MCPプロトコルを活用するのが最も効果的！ローカルLLMの性能も向上しているので、実用的な環境が構築できるよ〜✨
+
+どの方法から試してみる？アイが一緒に設定をお手伝いするからね！

docs/local-claude-code-setup.md

@@ -0,0 +1,338 @@
+# ローカルClaude Code環境構築ガイド
+RTX 4060 Ti + Qwen2.5-Coder + MCP Server
+
+## 1. 必要なツールのインストール
+
+### Ollamaのセットアップ
+```bash
+# Ollamaのインストール（Windows）
+# https://ollama.com からダウンロード
+
+# Qwen2.5-Coderモデルをダウンロード
+ollama pull qwen2.5-coder:14b-instruct-q4_K_M
+# または7Bバージョン（軽量）
+ollama pull qwen2.5-coder:7b-instruct-q4_K_M
+```
+
+### Python環境の準備
+```bash
+# 仮想環境作成
+python -m venv claude-code-env
+claude-code-env\Scripts\activate  # Windows
+# source claude-code-env/bin/activate  # Linux/Mac
+
+# 必要なパッケージをインストール
+pip install requests ollama-python rich click pathspec gitpython
+```
+
+## 2. メインスクリプトの作成
+
+### claude_code.py
+```python
+#!/usr/bin/env python3
+import os
+import sys
+import json
+import click
+import requests
+from pathlib import Path
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.syntax import Syntax
+
+console = Console()
+
+class LocalClaudeCode:
+    def __init__(self, model="qwen2.5-coder:14b-instruct-q4_K_M"):
+        self.model = model
+        self.ollama_url = "http://localhost:11434"
+        self.conversation_history = []
+        self.project_context = ""
+        
+    def get_project_context(self):
+        """プロジェクトのファイル構造とGitステータスを取得"""
+        context = []
+        
+        # ファイル構造
+        try:
+            for root, dirs, files in os.walk("."):
+                # .git, node_modules, __pycache__ などを除外
+                dirs[:] = [d for d in dirs if not d.startswith('.') and d not in ['node_modules', '__pycache__']]
+                level = root.replace(".", "").count(os.sep)
+                indent = " " * 2 * level
+                context.append(f"{indent}{os.path.basename(root)}/")
+                subindent = " " * 2 * (level + 1)
+                for file in files:
+                    if not file.startswith('.'):
+                        context.append(f"{subindent}{file}")
+        except Exception as e:
+            context.append(f"Error reading directory: {e}")
+            
+        return "\n".join(context[:50])  # 最初の50行まで
+    
+    def read_file(self, filepath):
+        """ファイルを読み込む"""
+        try:
+            with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+                return f.read()
+        except Exception as e:
+            return f"Error reading file: {e}"
+    
+    def write_file(self, filepath, content):
+        """ファイルに書き込む"""
+        try:
+            os.makedirs(os.path.dirname(filepath), exist_ok=True)
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(content)
+            return f"✅ File written: {filepath}"
+        except Exception as e:
+            return f"❌ Error writing file: {e}"
+    
+    def call_ollama(self, prompt):
+        """Ollamaにリクエストを送信"""
+        try:
+            response = requests.post(
+                f"{self.ollama_url}/api/generate",
+                json={
+                    "model": self.model,
+                    "prompt": prompt,
+                    "stream": False,
+                    "options": {
+                        "temperature": 0.1,
+                        "top_p": 0.95,
+                        "num_predict": 2048
+                    }
+                }
+            )
+            if response.status_code == 200:
+                return response.json()["response"]
+            else:
+                return f"Error: {response.status_code} - {response.text}"
+        except Exception as e:
+            return f"Connection error: {e}"
+    
+    def process_command(self, user_input):
+        """ユーザーの指示を処理"""
+        # プロジェクトコンテキストを更新
+        self.project_context = self.get_project_context()
+        
+        # システムプロンプト
+        system_prompt = f"""You are an expert coding assistant. You can:
+1. Read and analyze code files
+2. Write and modify files
+3. Explain code and provide suggestions
+4. Debug and fix issues
+
+Current project structure:
+{self.project_context}
+
+When you need to read a file, respond with: READ_FILE: <filepath>
+When you need to write a file, respond with: WRITE_FILE: <filepath>
+```
+<file content>
+```
+
+User request: {user_input}
+"""
+        
+        response = self.call_ollama(system_prompt)
+        return self.process_response(response)
+    
+    def process_response(self, response):
+        """レスポンスを処理してファイル操作を実行"""
+        lines = response.split('\n')
+        processed_response = []
+        
+        i = 0
+        while i < len(lines):
+            line = lines[i].strip()
+            
+            if line.startswith("READ_FILE:"):
+                filepath = line.replace("READ_FILE:", "").strip()
+                content = self.read_file(filepath)
+                processed_response.append(f"📁 Reading {filepath}:")
+                processed_response.append(f"```\n{content}\n```")
+                
+            elif line.startswith("WRITE_FILE:"):
+                filepath = line.replace("WRITE_FILE:", "").strip()
+                i += 1
+                # 次の```まで読み込む
+                if i < len(lines) and lines[i].strip() == "```":
+                    i += 1
+                    file_content = []
+                    while i < len(lines) and lines[i].strip() != "```":
+                        file_content.append(lines[i])
+                        i += 1
+                    content = '\n'.join(file_content)
+                    result = self.write_file(filepath, content)
+                    processed_response.append(result)
+                else:
+                    processed_response.append("❌ Invalid WRITE_FILE format")
+            else:
+                processed_response.append(line)
+            
+            i += 1
+        
+        return '\n'.join(processed_response)
+
+@click.command()
+@click.option('--model', default="qwen2.5-coder:14b-instruct-q4_K_M", help='Ollama model to use')
+@click.option('--interactive', '-i', is_flag=True, help='Interactive mode')
+@click.argument('prompt', required=False)
+def main(model, interactive, prompt):
+    """Local Claude Code - AI Coding Assistant"""
+    
+    claude = LocalClaudeCode(model)
+    
+    if interactive or not prompt:
+        console.print("[bold green]🤖 Local Claude Code Assistant[/bold green]")
+        console.print(f"Model: {model}")
+        console.print("Type 'quit' to exit\n")
+        
+        while True:
+            try:
+                user_input = input("👤 You: ").strip()
+                if user_input.lower() in ['quit', 'exit', 'q']:
+                    break
+                
+                if user_input:
+                    console.print("\n🤖 Assistant:")
+                    response = claude.process_command(user_input)
+                    console.print(Markdown(response))
+                    console.print()
+                    
+            except KeyboardInterrupt:
+                console.print("\n👋 Goodbye!")
+                break
+    else:
+        response = claude.process_command(prompt)
+        console.print(response)
+
+if __name__ == "__main__":
+    main()
+```
+
+## 3. MCP Server統合
+
+### mcp_integration.py
+```python
+import json
+import subprocess
+from typing import Dict, List, Any
+
+class MCPIntegration:
+    def __init__(self):
+        self.servers = {}
+    
+    def add_server(self, name: str, command: List[str], args: Dict[str, Any] = None):
+        """MCPサーバーを追加"""
+        self.servers[name] = {
+            "command": command,
+            "args": args or {}
+        }
+    
+    def call_mcp_tool(self, server_name: str, tool_name: str, arguments: Dict[str, Any]):
+        """MCPツールを呼び出す"""
+        if server_name not in self.servers:
+            return {"error": f"Server {server_name} not found"}
+        
+        try:
+            # MCPサーバーとの通信（JSONRPCベース）
+            request = {
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": f"tools/{tool_name}",
+                "params": {"arguments": arguments}
+            }
+            
+            process = subprocess.Popen(
+                self.servers[server_name]["command"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            stdout, stderr = process.communicate(json.dumps(request))
+            
+            if stderr:
+                return {"error": stderr}
+            
+            return json.loads(stdout)
+            
+        except Exception as e:
+            return {"error": str(e)}
+
+# 使用例
+mcp = MCPIntegration()
+mcp.add_server("filesystem", ["python", "-m", "mcp_server_filesystem"])
+mcp.add_server("git", ["python", "-m", "mcp_server_git"])
+```
+
+## 4. 設定ファイル
+
+### config.json
+```json
+{
+  "model": "qwen2.5-coder:14b-instruct-q4_K_M",
+  "ollama_url": "http://localhost:11434",
+  "mcp_servers": {
+    "filesystem": {
+      "command": ["python", "-m", "mcp_server_filesystem"],
+      "args": {"allowed_directories": ["."]}
+    },
+    "git": {
+      "command": ["python", "-m", "mcp_server_git"]
+    }
+  },
+  "excluded_files": [".git", "node_modules", "__pycache__", "*.pyc"],
+  "max_file_size": 1048576
+}
+```
+
+## 5. 使用方法
+
+### 基本的な使い方
+```bash
+# インタラクティブモード
+python claude_code.py -i
+
+# 単発コマンド
+python claude_code.py "Pythonでクイックソートを実装して"
+
+# 特定のモデルを使用
+python claude_code.py --model qwen2.5-coder:7b-instruct-q4_K_M -i
+```
+
+### MCP Serverのセットアップ
+```bash
+# 必要なMCPサーバーをインストール
+pip install mcp-server-git mcp-server-filesystem
+
+# 設定ファイルを編集してMCPサーバーを有効化
+```
+
+## 6. 機能一覧
+
+- ✅ ローカルLLMとの対話
+- ✅ ファイル読み書き
+- ✅ プロジェクト構造の自動認識
+- ✅ Gitステータス表示
+- ✅ シンタックスハイライト
+- ✅ MCP Server統合（オプション）
+- ✅ 設定ファイル対応
+
+## 7. トラブルシューティング
+
+### よくある問題
+1. **Ollamaが起動しない**: `ollama serve` でサーバーを起動
+2. **モデルが見つからない**: `ollama list` でインストール済みモデルを確認
+3. **メモリ不足**: より軽量な7Bモデルを使用
+4. **ファイル権限エラー**: 実行権限を確認
+
+### パフォーマンス最適化
+- GPU使用を確認: `nvidia-smi` でVRAM使用量をチェック
+- モデルサイズの調整: Q4_K_M → Q4_K_S で軽量化
+- コンテキスト長を調整して応答速度を向上
+
+重い場合は7Bバージョン（qwen2.5-coder:7b-instruct-q4_K_M）に変更。

docs/local-llm-recommendations.md

@@ -0,0 +1,133 @@
+# おすすめローカルLLM（RTX 4060 Ti 16GB対応）
+
+RTX 4060 Ti 16GBにぴったりのローカルLLMをご紹介します！
+
+## 🏆 アイのおすすめトップモデル（2025年版）
+
+### コーディング特化
+
+#### 1. **Qwen2.5-Coder-14B-Instruct** 🥇
+- **特徴**: コーディングで最強クラス！
+- **推奨量子化**: Q4_K_M（約8GB VRAM使用）
+- **用途**: プログラミング、コード生成・デバッグ
+- **お兄ちゃんのGPUに最適**
+
+#### 2. **DeepSeek-Coder-V2-Lite-16B**
+- **特徴**: コーディングと数学に特に強い
+- **推奨量子化**: Q4_K_M（約9GB VRAM使用）
+- **用途**: 複雑なアルゴリズム、数学的計算
+
+### 汎用・バランス型
+
+#### 3. **Qwen2.5-14B-Instruct** 🥈
+- **特徴**: 日本語も得意な万能モデル
+- **推奨量子化**: Q4_K_M（約8GB VRAM使用）
+- **用途**: 汎用タスク、日本語対話
+
+#### 4. **Llama 3.3-70B-Instruct（量子化）**
+- **特徴**: 405Bモデルに匹敵する性能
+- **推奨量子化**: Q3_K_S（約14GB VRAM使用）
+- **用途**: 高度な推論タスク
+- **注意**: ギリギリ動作、他のアプリケーション注意
+
+#### 5. **Mistral-Nemo-12B-Instruct**
+- **特徴**: バランスが良くて軽量
+- **推奨量子化**: Q5_K_M（約7GB VRAM使用）
+- **用途**: 日常的なタスク、軽快な動作
+
+### 最新・注目株
+
+#### 6. **Phi-4-14B**
+- **特徴**: Microsoftの最新モデル
+- **推奨量子化**: Q4_K_M（約8GB VRAM使用）
+- **用途**: 最新技術の体験
+
+#### 7. **DeepSeek-R1-Distill-Qwen-14B**
+- **特徴**: 推論特化の新しいモデル、OpenAI-o1に匹敵
+- **推奨量子化**: Q4_K_M（約8GB VRAM使用）
+- **用途**: 複雑な推論タスク
+
+## RTX 4060 Ti 16GB 推奨設定
+
+| モデルサイズ | 推奨量子化 | VRAM使用量 | 実行速度 | 品質 |
+|-------------|-----------|-----------|---------|------|
+| 7B | Q5_K_M | ~5GB | 🟢 速い | 良い |
+| 14B | Q4_K_M | ~8GB | 🟡 普通 | 高い |
+| 22B | Q4_K_S | ~12GB | 🟠 やや遅い | 高い |
+| 34B | Q3_K_S | ~15GB | 🔴 遅い | 最高 |
+
+## アイの一番のおすすめ
+
+### 用途別推奨モデル
+
+- **🔧 コーディング重視**: Qwen2.5-Coder-14B Q4_K_M
+- **💬 汎用対話**: Qwen2.5-14B-Instruct Q4_K_M  
+- **⚡ 軽さ重視**: Mistral-Nemo-12B Q5_K_M
+- **🧠 推論重視**: DeepSeek-R1-Distill-Qwen-14B Q4_K_M
+
+## インストール方法
+
+### Ollamaを使用した場合
+
+```bash
+# コーディング特化
+ollama pull qwen2.5-coder:14b-instruct-q4_K_M
+
+# 汎用モデル
+ollama pull qwen2.5:14b-instruct-q4_K_M
+
+# 軽量モデル
+ollama pull mistral-nemo:12b-instruct-q5_K_M
+
+# 最新推論モデル
+ollama pull deepseek-r1-distill-qwen:14b-q4_K_M
+```
+
+### 使用例
+
+```bash
+# インタラクティブ使用
+ollama run qwen2.5-coder:14b-instruct-q4_K_M
+
+# APIとして使用
+curl http://localhost:11434/api/generate -d '{
+  "model": "qwen2.5-coder:14b-instruct-q4_K_M",
+  "prompt": "Pythonでクイックソートを実装して"
+}'
+```
+
+## パフォーマンスのコツ
+
+### VRAM最適化
+- **16GB VRAM**: 14Bモデル Q4_K_M が最適
+- **余裕がある場合**: Q5_K_M で品質向上
+- **複数モデル併用**: 7Bモデルと組み合わせ
+
+### 速度向上
+- **GPU使用確認**: `nvidia-smi` でVRAM使用量チェック
+- **量子化レベル調整**: Q4_K_M → Q4_K_S で軽量化
+- **コンテキスト長調整**: 応答速度とバランス
+
+## トラブルシューティング
+
+### よくある問題
+
+1. **VRAM不足**
+   - より軽い量子化（Q4_K_S, Q3_K_M）を試す
+   - モデルサイズを下げる（14B → 7B）
+
+2. **動作が遅い**
+   - GPU使用を確認
+   - バックグラウンドアプリケーションを終了
+
+3. **品質が低い**
+   - より大きなモデルサイズを試す
+   - 高品質量子化（Q5_K_M, Q8_0）を使用
+
+## 結論
+
+RTX 4060 Ti 16GBなら、高品質量子化（Q5_K_M, Q8_0）でも快適に動作します。用途に応じてモデルを選択し、最適な設定で楽しいローカルLLM体験をお楽しみください！
+
+---
+
+*このガイドは2025年5月時点の情報に基づいています。新しいモデルが随時リリースされるため、最新情報もチェックしてくださいね〜♪*

docs/mcp-server-local-llm.py

@@ -0,0 +1,392 @@
+#!/usr/bin/env python3
+"""
+Local LLM MCP Server for Claude Code Integration
+Claude Code → MCP Server → Local LLM (Qwen2.5-Coder)
+"""
+
+import asyncio
+import json
+import logging
+import requests
+import subprocess
+import os
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+from mcp.server import Server
+from mcp.types import (
+    Tool, 
+    TextContent, 
+    Resource,
+    PromptMessage,
+    GetPromptResult
+)
+
+# ログ設定
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("local-llm-mcp")
+
+class LocalLLMServer:
+    def __init__(self, model: str = "qwen2.5-coder:14b-instruct-q4_K_M"):
+        self.model = model
+        self.ollama_url = "http://localhost:11434"
+        self.conversation_history = []
+        
+    def call_ollama(self, prompt: str, system_prompt: str = "") -> str:
+        """Ollamaにリクエストを送信"""
+        try:
+            full_prompt = f"{system_prompt}\n\nUser: {prompt}\nAssistant:"
+            
+            response = requests.post(
+                f"{self.ollama_url}/api/generate",
+                json={
+                    "model": self.model,
+                    "prompt": full_prompt,
+                    "stream": False,
+                    "options": {
+                        "temperature": 0.1,
+                        "top_p": 0.95,
+                        "num_predict": 2048,
+                        "stop": ["User:", "Human:"]
+                    }
+                },
+                timeout=60
+            )
+            
+            if response.status_code == 200:
+                return response.json()["response"].strip()
+            else:
+                return f"Error: {response.status_code} - {response.text}"
+                
+        except Exception as e:
+            logger.error(f"Ollama call failed: {e}")
+            return f"Connection error: {e}"
+    
+    def get_project_context(self) -> str:
+        """現在のプロジェクトの情報を取得"""
+        context = []
+        
+        # 現在のディレクトリ
+        cwd = os.getcwd()
+        context.append(f"Current directory: {cwd}")
+        
+        # Git情報
+        try:
+            git_status = subprocess.run(
+                ["git", "status", "--porcelain"], 
+                capture_output=True, text=True, cwd=cwd
+            )
+            if git_status.returncode == 0:
+                context.append(f"Git status: {git_status.stdout.strip() or 'Clean'}")
+        except:
+            context.append("Git: Not a git repository")
+        
+        # ファイル構造（簡略版）
+        try:
+            files = []
+            for item in Path(cwd).iterdir():
+                if not item.name.startswith('.') and item.name not in ['node_modules', '__pycache__']:
+                    if item.is_file():
+                        files.append(f"📄 {item.name}")
+                    elif item.is_dir():
+                        files.append(f"📁 {item.name}/")
+            
+            if files:
+                context.append("Project files:")
+                context.extend(files[:10])  # 最初の10個まで
+                
+        except Exception as e:
+            context.append(f"File listing error: {e}")
+        
+        return "\n".join(context)
+
+# MCPサーバーのセットアップ
+app = Server("local-llm-mcp")
+llm = LocalLLMServer()
+
+@app.tool("code_with_local_llm")
+async def code_with_local_llm(
+    task: str,
+    include_context: bool = True,
+    model_override: str = ""
+) -> str:
+    """
+    ローカルLLMでコーディングタスクを実行
+    
+    Args:
+        task: 実行したいコーディングタスク
+        include_context: プロジェクトコンテキストを含めるか
+        model_override: 使用するモデルを一時的に変更
+    """
+    logger.info(f"Executing coding task: {task}")
+    
+    # モデルの一時変更
+    original_model = llm.model
+    if model_override:
+        llm.model = model_override
+    
+    try:
+        # システムプロンプト構築
+        system_prompt = """You are an expert coding assistant. You can:
+1. Write, analyze, and debug code
+2. Explain programming concepts
+3. Suggest optimizations and best practices
+4. Generate complete, working solutions
+
+Always provide:
+- Clear, commented code
+- Explanations of your approach
+- Any assumptions you've made
+- Suggestions for improvements
+
+Format your response clearly with code blocks and explanations."""
+
+        # プロジェクトコンテキストを追加
+        if include_context:
+            context = llm.get_project_context()
+            system_prompt += f"\n\nCurrent project context:\n{context}"
+        
+        # LLMに送信
+        response = llm.call_ollama(task, system_prompt)
+        
+        return response
+        
+    except Exception as e:
+        logger.error(f"Code generation failed: {e}")
+        return f"❌ Error in code generation: {e}"
+    finally:
+        # モデルを元に戻す
+        llm.model = original_model
+
+@app.tool("read_file_with_analysis")
+async def read_file_with_analysis(
+    filepath: str,
+    analysis_type: str = "general"
+) -> str:
+    """
+    ファイルを読み込んでLLMで分析
+    
+    Args:
+        filepath: 分析するファイルのパス
+        analysis_type: 分析タイプ (general, bugs, optimization, documentation)
+    """
+    logger.info(f"Analyzing file: {filepath}")
+    
+    try:
+        # ファイル読み込み
+        with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+            content = f.read()
+        
+        # 分析タイプに応じたプロンプト
+        analysis_prompts = {
+            "general": "Analyze this code and provide a general overview, including its purpose, structure, and key components.",
+            "bugs": "Review this code for potential bugs, errors, or issues. Suggest fixes if found.",
+            "optimization": "Analyze this code for performance optimizations and suggest improvements.",
+            "documentation": "Generate comprehensive documentation for this code, including docstrings and comments."
+        }
+        
+        prompt = f"{analysis_prompts.get(analysis_type, analysis_prompts['general'])}\n\nFile: {filepath}\n\nCode:\n```\n{content}\n```"
+        
+        system_prompt = "You are a code review expert. Provide detailed, constructive analysis."
+        
+        response = llm.call_ollama(prompt, system_prompt)
+        
+        return f"📋 Analysis of {filepath}:\n\n{response}"
+        
+    except FileNotFoundError:
+        return f"❌ File not found: {filepath}"
+    except Exception as e:
+        logger.error(f"File analysis failed: {e}")
+        return f"❌ Error analyzing file: {e}"
+
+@app.tool("write_code_to_file")
+async def write_code_to_file(
+    filepath: str,
+    task_description: str,
+    overwrite: bool = False
+) -> str:
+    """
+    LLMでコードを生成してファイルに書き込み
+    
+    Args:
+        filepath: 書き込み先のファイルパス
+        task_description: コード生成のタスク説明
+        overwrite: 既存ファイルを上書きするか
+    """
+    logger.info(f"Generating code for file: {filepath}")
+    
+    try:
+        # 既存ファイルのチェック
+        if os.path.exists(filepath) and not overwrite:
+            return f"❌ File already exists: {filepath}. Use overwrite=true to replace."
+        
+        # ファイル拡張子から言語を推定
+        ext = Path(filepath).suffix.lower()
+        language_map = {
+            '.py': 'Python',
+            '.js': 'JavaScript',
+            '.ts': 'TypeScript',
+            '.java': 'Java',
+            '.cpp': 'C++',
+            '.c': 'C',
+            '.rs': 'Rust',
+            '.go': 'Go'
+        }
+        language = language_map.get(ext, 'appropriate language')
+        
+        # コード生成プロンプト
+        prompt = f"""Generate {language} code for the following task and save it to {filepath}:
+
+Task: {task_description}
+
+Requirements:
+- Write complete, working code
+- Include appropriate comments
+- Follow best practices for {language}
+- Make the code production-ready
+
+Return ONLY the code that should be saved to the file, without any additional explanation or markdown formatting."""
+        
+        system_prompt = f"You are an expert {language} developer. Generate clean, efficient, well-documented code."
+        
+        # コード生成
+        generated_code = llm.call_ollama(prompt, system_prompt)
+        
+        # ファイルに書き込み
+        os.makedirs(os.path.dirname(filepath), exist_ok=True)
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(generated_code)
+        
+        return f"✅ Code generated and saved to {filepath}\n\nGenerated code:\n```{language.lower()}\n{generated_code}\n```"
+        
+    except Exception as e:
+        logger.error(f"Code generation and file writing failed: {e}")
+        return f"❌ Error: {e}"
+
+@app.tool("debug_with_llm")
+async def debug_with_llm(
+    error_message: str,
+    code_context: str = "",
+    filepath: str = ""
+) -> str:
+    """
+    エラーメッセージとコードコンテキストでデバッグ支援
+    
+    Args:
+        error_message: エラーメッセージ
+        code_context: エラーが発生したコードの部分
+        filepath: エラーが発生したファイル（オプション）
+    """
+    logger.info("Debugging with LLM")
+    
+    try:
+        # ファイルが指定されていれば読み込み
+        if filepath and os.path.exists(filepath):
+            with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+                file_content = f.read()
+            code_context = f"Full file content:\n{file_content}"
+        
+        prompt = f"""Help debug this error:
+
+Error message: {error_message}
+
+Code context:
+{code_context}
+
+Please:
+1. Explain what's causing the error
+2. Provide a specific solution
+3. Show the corrected code if applicable
+4. Suggest ways to prevent similar errors"""
+        
+        system_prompt = "You are an expert debugger. Provide clear, actionable solutions to programming errors."
+        
+        response = llm.call_ollama(prompt, system_prompt)
+        
+        return f"🔧 Debug Analysis:\n\n{response}"
+        
+    except Exception as e:
+        logger.error(f"Debugging failed: {e}")
+        return f"❌ Debug error: {e}"
+
+@app.tool("explain_code")
+async def explain_code(
+    code: str,
+    detail_level: str = "medium"
+) -> str:
+    """
+    コードの説明を生成
+    
+    Args:
+        code: 説明するコード
+        detail_level: 説明の詳細レベル (basic, medium, detailed)
+    """
+    logger.info("Explaining code with LLM")
+    
+    try:
+        detail_prompts = {
+            "basic": "Provide a brief, high-level explanation of what this code does.",
+            "medium": "Explain this code in detail, including its purpose, how it works, and key components.",
+            "detailed": "Provide a comprehensive explanation including line-by-line analysis, design patterns used, and potential improvements."
+        }
+        
+        prompt = f"{detail_prompts.get(detail_level, detail_prompts['medium'])}\n\nCode:\n```\n{code}\n```"
+        
+        system_prompt = "You are a programming instructor. Explain code clearly and educationally."
+        
+        response = llm.call_ollama(prompt, system_prompt)
+        
+        return f"📚 Code Explanation:\n\n{response}"
+        
+    except Exception as e:
+        logger.error(f"Code explanation failed: {e}")
+        return f"❌ Explanation error: {e}"
+
+@app.tool("switch_model")
+async def switch_model(model_name: str) -> str:
+    """
+    使用するローカルLLMモデルを切り替え
+    
+    Args:
+        model_name: 切り替え先のモデル名
+    """
+    logger.info(f"Switching model to: {model_name}")
+    
+    try:
+        # モデルの存在確認
+        response = requests.get(f"{llm.ollama_url}/api/tags")
+        if response.status_code == 200:
+            models = response.json().get("models", [])
+            available_models = [model["name"] for model in models]
+            
+            if model_name in available_models:
+                llm.model = model_name
+                return f"✅ Model switched to: {model_name}"
+            else:
+                return f"❌ Model not found. Available models: {', '.join(available_models)}"
+        else:
+            return "❌ Cannot check available models"
+            
+    except Exception as e:
+        logger.error(f"Model switching failed: {e}")
+        return f"❌ Error switching model: {e}"
+
+async def main():
+    """MCPサーバーを起動"""
+    logger.info("Starting Local LLM MCP Server...")
+    logger.info(f"Using model: {llm.model}")
+    
+    # Ollamaの接続確認
+    try:
+        response = requests.get(f"{llm.ollama_url}/api/tags", timeout=5)
+        if response.status_code == 200:
+            logger.info("✅ Ollama connection successful")
+        else:
+            logger.warning("⚠️ Ollama connection issue")
+    except Exception as e:
+        logger.error(f"❌ Cannot connect to Ollama: {e}")
+    
+    # サーバー起動
+    await app.run()
+
+if __name__ == "__main__":
+    asyncio.run(main())

docs/mcp-setup-guide.md

@@ -0,0 +1,244 @@
+# MCP Server セットアップガイド
+Claude Code + ローカルLLM統合環境
+
+## 🚀 セットアップ手順
+
+### 1. 依存関係のインストール
+
+```bash
+# 仮想環境作成
+python -m venv mcp-env
+mcp-env\Scripts\activate  # Windows
+# source mcp-env/bin/activate  # Linux/Mac
+
+# 必要なパッケージをインストール
+pip install mcp requests pathlib asyncio
+```
+
+### 2. Ollamaのセットアップ
+
+```bash
+# Ollamaのインストール（https://ollama.com）
+# Windows: インストーラーをダウンロード
+# Linux: curl -fsSL https://ollama.com/install.sh | sh
+
+# Qwen2.5-Coderモデルをダウンロード
+ollama pull qwen2.5-coder:14b-instruct-q4_K_M
+
+# Ollamaサーバー起動確認
+ollama serve
+```
+
+### 3. Claude Desktop設定
+
+#### claude_desktop_config.json の作成
+**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+**Linux**: `~/.config/claude/claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "local-llm": {
+      "command": "python",
+      "args": ["/path/to/your/local_llm_mcp_server.py"],
+      "env": {
+        "OLLAMA_URL": "http://localhost:11434",
+        "DEFAULT_MODEL": "qwen2.5-coder:14b-instruct-q4_K_M"
+      }
+    }
+  }
+}
+```
+
+### 4. Claude Code設定
+
+```bash
+# Claude Codeをインストール（既にインストール済みの場合はスキップ）
+# 公式サイトからダウンロード
+
+# MCP サーバーを追加
+claude mcp add local-llm
+
+# または手動で設定ファイルを編集
+# ~/.config/claude-code/config.json
+```
+
+## 🎯 使用方法
+
+### Claude Codeから使用
+
+```bash
+# Claude Codeを起動
+claude code
+
+# プロンプト例:
+# "Use local LLM to implement a Python quicksort function"
+# "Analyze main.py with local model for potential bugs"
+# "Generate a REST API using the local coding model"
+```
+
+### 利用可能なツール
+
+1. **code_with_local_llm**
+   - タスク: `"Implement a binary search tree in Python"`
+   - プロジェクトコンテキスト含む: `true`
+
+2. **read_file_with_analysis**
+   - ファイルパス: `"src/main.py"`
+   - 分析タイプ: `"bugs"` | `"optimization"` | `"documentation"`
+
+3. **write_code_to_file**
+   - ファイルパス: `"utils/helpers.py"`
+   - タスク説明: `"Create utility functions for data processing"`
+
+4. **debug_with_llm**
+   - エラーメッセージ: `"IndexError: list index out of range"`
+   - コードコンテキスト: 該当するコード部分
+
+5. **explain_code**
+   - コード: 解説したいコード
+   - 詳細レベル: `"basic"` | `"medium"` | `"detailed"`
+
+6. **switch_model**
+   - モデル名: `"qwen2.5-coder:7b-instruct"`
+
+## 🔧 カスタマイズ
+
+### モデル設定の変更
+
+```python
+# デフォルトモデルの変更
+llm = LocalLLMServer("deepseek-coder:6.7b-instruct-q4_K_M")
+
+# 複数モデル対応
+models = {
+    "coding": "qwen2.5-coder:14b-instruct-q4_K_M",
+    "general": "qwen2.5:14b-instruct-q4_K_M",
+    "light": "mistral-nemo:12b-instruct-q5_K_M"
+}
+```
+
+### プロンプトのカスタマイズ
+
+```python
+# システムプロンプトの調整
+system_prompt = """You are an expert coding assistant specialized in:
+- Clean, efficient code generation
+- Best practices and design patterns
+- Security-conscious development
+- Performance optimization
+
+Always provide:
+- Working, tested code
+- Comprehensive comments
+- Error handling
+- Performance considerations"""
+```
+
+## 🛠️ トラブルシューティング
+
+### よくある問題
+
+1. **MCPサーバーが起動しない**
+```bash
+# ログ確認
+tail -f ~/.config/claude-desktop/logs/mcp.log
+
+# Pythonパスの確認
+which python
+```
+
+2. **Ollamaに接続できない**
+```bash
+# Ollamaの状態確認
+ollama ps
+curl http://localhost:11434/api/tags
+
+# サービス再起動
+ollama serve
+```
+
+3. **モデルが見つからない**
+```bash
+# インストール済みモデル確認
+ollama list
+
+# モデルの再ダウンロード
+ollama pull qwen2.5-coder:14b-instruct-q4_K_M
+```
+
+### パフォーマンス最適化
+
+```python
+# Ollamaの設定調整
+{
+    "temperature": 0.1,      # 一貫性重視
+    "top_p": 0.95,          # 品質バランス
+    "num_predict": 2048,    # 応答長制限
+    "num_ctx": 4096         # コンテキスト長
+}
+```
+
+### セキュリティ設定
+
+```python
+# ファイルアクセス制限
+ALLOWED_DIRECTORIES = [
+    os.getcwd(),
+    os.path.expanduser("~/projects")
+]
+
+# 実行可能コマンドの制限
+ALLOWED_COMMANDS = ["git", "python", "node", "npm"]
+```
+
+## 🎉 使用例
+
+### 1. 新機能の実装
+```
+Claude Code Prompt:
+"Use local LLM to create a user authentication system with JWT tokens in Python Flask"
+
+→ MCPサーバーがローカルLLMでコード生成
+→ ファイルに自動保存
+→ Claude Codeが結果を表示
+```
+
+### 2. バグ修正
+```
+Claude Code Prompt:
+"Analyze app.py for bugs and fix them using the local model"
+
+→ ファイル読み込み + LLM分析
+→ 修正版コードを生成
+→ バックアップ作成後に上書き
+```
+
+### 3. コードレビュー
+```
+Claude Code Prompt:
+"Review the entire codebase with local LLM and provide optimization suggestions"
+
+→ プロジェクト全体をスキャン
+→ 各ファイルをLLMで分析
+→ 改善提案をレポート形式で生成
+```
+
+## 📊 パフォーマンス比較
+
+| 機能 | Claude Code (公式) | ローカルLLM + MCP |
+|------|-------------------|-------------------|
+| 応答速度 | ⚡ 高速 | 🟡 中程度 |
+| プライバシー | 🟡 クラウド | 🟢 完全ローカル |
+| カスタマイズ | 🟡 限定的 | 🟢 完全自由 |
+| コスト | 💰 従量課金 | 🟢 無料 |
+| 専門性 | 🟢 汎用的 | 🟢 カスタマイズ可能 |
+
+## 🔄 今後の拡張
+
+- [ ] 複数LLMモデルの同時利用
+- [ ] コード実行環境の統合
+- [ ] Gitワークフローの自動化
+- [ ] プロジェクトテンプレートの生成
+- [ ] 自動テスト生成機能