mycode-aiagent 0.4.1__tar.gz → 0.4.3__tar.gz

{mycode_aiagent-0.4.1 → mycode_aiagent-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-aiagent
-Version: 0.4.1
+Version: 0.4.3
 Summary: Style-aware code generation — analyze any codebase and generate new code that matches its style
 License: MIT
 Project-URL: Homepage, https://github.com/RyanAbbottData/MyCode
@@ -90,16 +90,29 @@ MyCode delegates inference to a pluggable backend. Choose one based on what you
 
 | Backend | Flag | Requirement |
 |---|---|---|
-| Local LLM | `--backend llama` (default) | MCP server running at `localhost:8000` |
-| Anthropic Claude | `--backend claude` | `ANTHROPIC_API_KEY` env var or `--api-key` |
+| Anthropic Claude | `--backend claude` (default) | `ANTHROPIC_API_KEY` env var or `--api-key` |
 | OpenAI | `--backend openai` | `OPENAI_API_KEY` env var or `--api-key` |
-| MyCode server | `--backend mcp` | A running MyCode MCP server at `--mcp-url` |
+| Local LLM (OpenAI-compatible) | `--backend local` | LLM server at `--llm-url` (default: `http://localhost:8080/v1`) |
+| Any MCP server | `--backend mcp` | A running MyCode MCP server at `--mcp-url` |
 
 When `--backend mcp` is used with `analyze` or `generate`, the CLI delegates the entire operation to the running MyCode server — it calls the server's `analyze_codebase` or `generate_code` tool directly instead of running the pipeline locally. This is the recommended way to use MyCode in a multi-project or agentic setup.
 
 ### Setting up a local LLM
 
-The `llama` backend expects an MCP server at `http://localhost:8000/mcp` that exposes two tools: one for code generation and one for analysis. Any MCP-compatible wrapper around a local model will work. Here is a recommended setup using [llama.cpp](https://github.com/ggerganov/llama.cpp):
+Use `--backend local` to connect MyCode directly to any OpenAI-compatible LLM server (llama.cpp, LM Studio, Ollama, etc.) — no wrapper needed. Point `--llm-url` at the server's `/v1` base URL:
+
+```bash
+# Start your local LLM server (example: llama.cpp)
+python -m llama_cpp.server --model ./models/codellama-7b-instruct.Q4_K_M.gguf --port 8080
+
+# Analyze using the local LLM directly
+my-code --backend local --llm-url http://localhost:8080/v1 analyze ./my_project
+
+# Or start a MyCode MCP server backed by your local LLM
+my-code --backend local --llm-url http://localhost:8080/v1 serve --port 8000 --daemon
+```
+
+If you need a full MCP-wrapped setup instead (e.g. the local LLM exposes only `/v1/completions` without chat completions), here is a recommended pattern using [llama.cpp](https://github.com/ggerganov/llama.cpp):
 
 **1. Download a model**
 
@@ -126,7 +139,7 @@ python -m llama_cpp.server \
 
 **3. Wrap it with an MCP server**
 
-The `llama` backend communicates over MCP, not directly with the llama.cpp HTTP API. You need a thin MCP wrapper that exposes two tools:
+The `mcp` backend communicates over MCP, not directly with the llama.cpp HTTP API. You need a thin MCP wrapper that exposes two tools:
 - A **code generation tool** (name must not contain `"analyze"`)
 - An **analysis tool** (name must contain `"analyze"`)
 
@@ -168,13 +181,13 @@ python llm_mcp_server.py
 **4. Point MyCode at it**
 
 ```bash
-my-code --backend llama --ricky-url http://localhost:8000/mcp analyze .
+my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze .
 ```
 
 Or set a custom URL if your server runs on a different port:
 
 ```bash
-my-code --backend llama --ricky-url http://localhost:9000/mcp analyze .
+my-code --backend mcp --mcp-url http://localhost:9000/mcp analyze .
 ```
 
 ---
@@ -198,6 +211,7 @@ Using a different backend:
 ```bash
 my-code --backend claude analyze ./path/to/codebase
 my-code --backend openai --api-key sk-... analyze ./path/to/codebase
+my-code --backend local --llm-url http://localhost:8080/v1 analyze ./path/to/codebase
 ```
 
 The profile is saved to `style_profile.json` by default. Specify a different path with `--profile`:
@@ -240,11 +254,11 @@ my-code --backend mcp --mcp-url http://localhost:8000/mcp generate "write a rate
 my-code [OPTIONS] COMMAND
 
 Options:
-  --backend {llama,claude,openai,mcp}   AI backend to use (default: llama)
+  --backend {claude,openai,local,mcp}    AI backend to use (default: claude)
   --api-key TEXT                         API key for claude/openai backends
   --model TEXT                           Override the default model
-  --ricky-url TEXT                       Local LLM MCP server URL (default: http://localhost:8000/mcp)
-  --mcp-url TEXT                         Custom MCP server URL (default: http://localhost:8001/mcp)
+  --mcp-url TEXT                         MyCode MCP server URL (mcp backend, default: http://localhost:8001/mcp)
+  --llm-url TEXT                         Base URL of a local OpenAI-compatible LLM server (local backend, default: http://localhost:8080/v1)
   --profile TEXT                         Path to style profile JSON (default: style_profile.json)
 
 Commands:
@@ -274,9 +288,10 @@ from my_code import StyleAnalyzer, generate_code, make_backend
 from pathlib import Path
 
 # Create a backend
-backend = make_backend()                           # local LLM (default)
-backend = make_backend("claude")                   # Claude (reads ANTHROPIC_API_KEY)
-backend = make_backend("openai", api_key="sk-...") # OpenAI
+backend = make_backend("claude")                                              # Claude (reads ANTHROPIC_API_KEY)
+backend = make_backend("openai", api_key="sk-...")                            # OpenAI (GPT models)
+backend = make_backend("local", llm_url="http://localhost:8080/v1")           # Local LLM (OpenAI-compatible)
+backend = make_backend("mcp",   mcp_url="http://localhost:8000/mcp")          # Delegate to a MyCode server
 
 # Analyze a codebase
 analyzer = StyleAnalyzer(backend)
@@ -328,15 +343,15 @@ MyCode can expose itself as an MCP server so any MCP-compatible agent or orchest
 ### Quick start
 
 ```bash
-# Local LLM backend (default) — foreground, blocks until Ctrl-C
-my-code serve
-
-# Claude backend
+# Claude backend — foreground, blocks until Ctrl-C
 my-code --backend claude serve --port 8080
 
 # OpenAI backend
 my-code --backend openai serve --port 8080
 
+# Local LLM (OpenAI-compatible server on port 8080)
+my-code --backend local --llm-url http://localhost:8080/v1 serve --port 8000
+
 # Bind on all interfaces
 my-code --backend claude serve --host 0.0.0.0 --port 8080
 ```
@@ -379,8 +394,8 @@ my-code stop --pid-file mycode-8081.pid
 Start a MyCode server as a daemon, then point `analyze` and `generate` at it with `--backend mcp`. The CLI calls the server's tools directly — the server handles all analysis and generation using whichever LLM it was started with.
 
 ```bash
-# Start the server (uses a local LLM at port 8001 as its brain)
-my-code --backend mcp --mcp-url http://localhost:8001/mcp serve --daemon --port 8000
+# Start the server backed by a local LLM
+my-code --backend local --llm-url http://localhost:8080/v1 serve --daemon --port 8000
 
 # Analyze a codebase via the server
 my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze ./my_project
@@ -476,7 +491,6 @@ my_code/
 ├── cli.py               # CLI entry point (my-code command)
 ├── backends/
 │   ├── base.py          # AIBackend abstract base class
-│   ├── ricky_backend.py # Local LLM backend (connects via MCP)
 │   ├── claude_backend.py
 │   ├── openai_backend.py
 │   └── mcp_backend.py   # Generic MCP server backend

{mycode_aiagent-0.4.1 → mycode_aiagent-0.4.3}/README.md

@@ -61,16 +61,29 @@ MyCode delegates inference to a pluggable backend. Choose one based on what you
 
 | Backend | Flag | Requirement |
 |---|---|---|
-| Local LLM | `--backend llama` (default) | MCP server running at `localhost:8000` |
-| Anthropic Claude | `--backend claude` | `ANTHROPIC_API_KEY` env var or `--api-key` |
+| Anthropic Claude | `--backend claude` (default) | `ANTHROPIC_API_KEY` env var or `--api-key` |
 | OpenAI | `--backend openai` | `OPENAI_API_KEY` env var or `--api-key` |
-| MyCode server | `--backend mcp` | A running MyCode MCP server at `--mcp-url` |
+| Local LLM (OpenAI-compatible) | `--backend local` | LLM server at `--llm-url` (default: `http://localhost:8080/v1`) |
+| Any MCP server | `--backend mcp` | A running MyCode MCP server at `--mcp-url` |
 
 When `--backend mcp` is used with `analyze` or `generate`, the CLI delegates the entire operation to the running MyCode server — it calls the server's `analyze_codebase` or `generate_code` tool directly instead of running the pipeline locally. This is the recommended way to use MyCode in a multi-project or agentic setup.
 
 ### Setting up a local LLM
 
-The `llama` backend expects an MCP server at `http://localhost:8000/mcp` that exposes two tools: one for code generation and one for analysis. Any MCP-compatible wrapper around a local model will work. Here is a recommended setup using [llama.cpp](https://github.com/ggerganov/llama.cpp):
+Use `--backend local` to connect MyCode directly to any OpenAI-compatible LLM server (llama.cpp, LM Studio, Ollama, etc.) — no wrapper needed. Point `--llm-url` at the server's `/v1` base URL:
+
+```bash
+# Start your local LLM server (example: llama.cpp)
+python -m llama_cpp.server --model ./models/codellama-7b-instruct.Q4_K_M.gguf --port 8080
+
+# Analyze using the local LLM directly
+my-code --backend local --llm-url http://localhost:8080/v1 analyze ./my_project
+
+# Or start a MyCode MCP server backed by your local LLM
+my-code --backend local --llm-url http://localhost:8080/v1 serve --port 8000 --daemon
+```
+
+If you need a full MCP-wrapped setup instead (e.g. the local LLM exposes only `/v1/completions` without chat completions), here is a recommended pattern using [llama.cpp](https://github.com/ggerganov/llama.cpp):
 
 **1. Download a model**
 
@@ -97,7 +110,7 @@ python -m llama_cpp.server \
 
 **3. Wrap it with an MCP server**
 
-The `llama` backend communicates over MCP, not directly with the llama.cpp HTTP API. You need a thin MCP wrapper that exposes two tools:
+The `mcp` backend communicates over MCP, not directly with the llama.cpp HTTP API. You need a thin MCP wrapper that exposes two tools:
 - A **code generation tool** (name must not contain `"analyze"`)
 - An **analysis tool** (name must contain `"analyze"`)
 
@@ -139,13 +152,13 @@ python llm_mcp_server.py
 **4. Point MyCode at it**
 
 ```bash
-my-code --backend llama --ricky-url http://localhost:8000/mcp analyze .
+my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze .
 ```
 
 Or set a custom URL if your server runs on a different port:
 
 ```bash
-my-code --backend llama --ricky-url http://localhost:9000/mcp analyze .
+my-code --backend mcp --mcp-url http://localhost:9000/mcp analyze .
 ```
 
 ---
@@ -169,6 +182,7 @@ Using a different backend:
 ```bash
 my-code --backend claude analyze ./path/to/codebase
 my-code --backend openai --api-key sk-... analyze ./path/to/codebase
+my-code --backend local --llm-url http://localhost:8080/v1 analyze ./path/to/codebase
 ```
 
 The profile is saved to `style_profile.json` by default. Specify a different path with `--profile`:
@@ -211,11 +225,11 @@ my-code --backend mcp --mcp-url http://localhost:8000/mcp generate "write a rate
 my-code [OPTIONS] COMMAND
 
 Options:
-  --backend {llama,claude,openai,mcp}   AI backend to use (default: llama)
+  --backend {claude,openai,local,mcp}    AI backend to use (default: claude)
   --api-key TEXT                         API key for claude/openai backends
   --model TEXT                           Override the default model
-  --ricky-url TEXT                       Local LLM MCP server URL (default: http://localhost:8000/mcp)
-  --mcp-url TEXT                         Custom MCP server URL (default: http://localhost:8001/mcp)
+  --mcp-url TEXT                         MyCode MCP server URL (mcp backend, default: http://localhost:8001/mcp)
+  --llm-url TEXT                         Base URL of a local OpenAI-compatible LLM server (local backend, default: http://localhost:8080/v1)
   --profile TEXT                         Path to style profile JSON (default: style_profile.json)
 
 Commands:
@@ -245,9 +259,10 @@ from my_code import StyleAnalyzer, generate_code, make_backend
 from pathlib import Path
 
 # Create a backend
-backend = make_backend()                           # local LLM (default)
-backend = make_backend("claude")                   # Claude (reads ANTHROPIC_API_KEY)
-backend = make_backend("openai", api_key="sk-...") # OpenAI
+backend = make_backend("claude")                                              # Claude (reads ANTHROPIC_API_KEY)
+backend = make_backend("openai", api_key="sk-...")                            # OpenAI (GPT models)
+backend = make_backend("local", llm_url="http://localhost:8080/v1")           # Local LLM (OpenAI-compatible)
+backend = make_backend("mcp",   mcp_url="http://localhost:8000/mcp")          # Delegate to a MyCode server
 
 # Analyze a codebase
 analyzer = StyleAnalyzer(backend)
@@ -299,15 +314,15 @@ MyCode can expose itself as an MCP server so any MCP-compatible agent or orchest
 ### Quick start
 
 ```bash
-# Local LLM backend (default) — foreground, blocks until Ctrl-C
-my-code serve
-
-# Claude backend
+# Claude backend — foreground, blocks until Ctrl-C
 my-code --backend claude serve --port 8080
 
 # OpenAI backend
 my-code --backend openai serve --port 8080
 
+# Local LLM (OpenAI-compatible server on port 8080)
+my-code --backend local --llm-url http://localhost:8080/v1 serve --port 8000
+
 # Bind on all interfaces
 my-code --backend claude serve --host 0.0.0.0 --port 8080
 ```
@@ -350,8 +365,8 @@ my-code stop --pid-file mycode-8081.pid
 Start a MyCode server as a daemon, then point `analyze` and `generate` at it with `--backend mcp`. The CLI calls the server's tools directly — the server handles all analysis and generation using whichever LLM it was started with.
 
 ```bash
-# Start the server (uses a local LLM at port 8001 as its brain)
-my-code --backend mcp --mcp-url http://localhost:8001/mcp serve --daemon --port 8000
+# Start the server backed by a local LLM
+my-code --backend local --llm-url http://localhost:8080/v1 serve --daemon --port 8000
 
 # Analyze a codebase via the server
 my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze ./my_project
@@ -447,7 +462,6 @@ my_code/
 ├── cli.py               # CLI entry point (my-code command)
 ├── backends/
 │   ├── base.py          # AIBackend abstract base class
-│   ├── ricky_backend.py # Local LLM backend (connects via MCP)
 │   ├── claude_backend.py
 │   ├── openai_backend.py
 │   └── mcp_backend.py   # Generic MCP server backend

{mycode_aiagent-0.4.1 → mycode_aiagent-0.4.3}/my_code/__init__.py

@@ -2,7 +2,7 @@ __version__ = "0.3.0"
 
 from .analyzer import StyleAnalyzer
 from .generator import generate_code
-from .backends import AIBackend, ClaudeBackend, OpenAIBackend, RickyBackend, MCPBackend, make_backend
+from .backends import AIBackend, ClaudeBackend, OpenAIBackend, MCPBackend, make_backend
 from .server import MCPServer
 
 
@@ -17,7 +17,6 @@ __all__ = [
     "AIBackend",
     "ClaudeBackend",
     "OpenAIBackend",
-    "RickyBackend",
     "MCPBackend",
     "make_backend",
     "MCPServer",

{mycode_aiagent-0.4.1 → mycode_aiagent-0.4.3}/my_code/backends/__init__.py

@@ -3,17 +3,15 @@ import os
 from .base import AIBackend
 from .claude_backend import ClaudeBackend
 from .openai_backend import OpenAIBackend
-from .ricky_backend import RickyBackend
 from .mcp_backend import MCPBackend
 
-__all__ = ["AIBackend", "ClaudeBackend", "OpenAIBackend", "RickyBackend", "MCPBackend", "make_backend"]
-
+__all__ = ["AIBackend", "ClaudeBackend", "OpenAIBackend", "MCPBackend", "make_backend"]
 
 def make_backend(
-    backend: str = "llama",
+    backend: str = "claude",
     api_key: str | None = None,
-    ricky_url: str = "http://localhost:8000/mcp",
     mcp_url: str = "http://localhost:8001/mcp",
+    llm_url: str = "http://localhost:8080/v1",
     model: str | None = None,
     timeout: int = 120,
 ) -> AIBackend:
@@ -27,8 +25,8 @@ def make_backend(
         if not key:
             raise ValueError("OpenAI backend requires OPENAI_API_KEY or --api-key")
         return OpenAIBackend(api_key=key, **{"model": model} if model else {})
+    if backend == "local":
+        return OpenAIBackend(api_key=api_key or "none", base_url=llm_url, **{"model": model} if model else {})
     if backend == "mcp":
         return MCPBackend(url=mcp_url, timeout=timeout)
-    if backend == "llama":
-        return RickyBackend(url=ricky_url, timeout=timeout)
-    raise ValueError(f"Unknown backend {backend!r}. Choose: llama, claude, openai, mcp")
+    raise ValueError(f"Unknown backend {backend!r}. Choose: claude, openai, local, mcp")

{mycode_aiagent-0.4.1 → mycode_aiagent-0.4.3}/my_code/backends/openai_backend.py

@@ -2,12 +2,15 @@ from .base import AIBackend
 
 
 class OpenAIBackend(AIBackend):
-    def __init__(self, api_key: str, model: str = "gpt-4o"):
+    def __init__(self, api_key: str, model: str = "gpt-4o", base_url: str | None = None):
         try:
             import openai
         except ImportError:
             raise ImportError("OpenAI backend requires 'openai': pip install 'my-code[openai]'")
-        self._client = openai.OpenAI(api_key=api_key)
+        client_kwargs = {"api_key": api_key}
+        if base_url is not None:
+            client_kwargs["base_url"] = base_url
+        self._client = openai.OpenAI(**client_kwargs)
         self._model = model
 
     def _call(self, system: str, prompt: str) -> str:

{mycode_aiagent-0.4.1 → mycode_aiagent-0.4.3}/my_code/cli.py

@@ -2,8 +2,8 @@
 Style-aware code generation agent.
 
 Usage:
-  my-code [--backend llama|claude|openai] analyze <dir>
-  my-code [--backend llama|claude|openai] --api-key <key> generate "<task>"
+  my-code [--backend claude|openai|local|mcp] analyze <dir>
+  my-code [--backend claude|openai|local|mcp] --api-key <key> generate "<task>"
 """
 
 import argparse
@@ -38,8 +38,8 @@ def cmd_analyze(args):
     backend = make_backend(
         backend=args.backend,
         api_key=args.api_key,
-        ricky_url=args.ricky_url,
         mcp_url=args.mcp_url,
+        llm_url=args.llm_url,
         model=args.model,
         timeout=args.timeout,
     )
@@ -70,8 +70,8 @@ def cmd_generate(args):
     backend = make_backend(
         backend=args.backend,
         api_key=args.api_key,
-        ricky_url=args.ricky_url,
         mcp_url=args.mcp_url,
+        llm_url=args.llm_url,
         model=args.model,
         timeout=args.timeout,
     )
@@ -87,8 +87,8 @@ def _spawn_daemon(args):
     cmd = [
         sys.executable, "-m", "my_code",
         "--backend", args.backend,
-        "--ricky-url", args.ricky_url,
         "--mcp-url", args.mcp_url,
+        "--llm-url", args.llm_url,
         "--timeout", str(args.timeout),
         "--profile", args.profile,
         "serve",
@@ -127,8 +127,8 @@ def cmd_serve(args):
     backend = make_backend(
         backend=args.backend,
         api_key=args.api_key,
-        ricky_url=args.ricky_url,
         mcp_url=args.mcp_url,
+        llm_url=args.llm_url,
         model=args.model,
         timeout=args.timeout,
     )
@@ -138,13 +138,13 @@ def cmd_serve(args):
 def main():
     parser = argparse.ArgumentParser(description="Style-aware code agent")
     parser.add_argument(
-        "--backend", default="llama", choices=["llama", "claude", "openai", "mcp"],
-        help="AI backend to use (default: llama)",
+        "--backend", default="claude", choices=["claude", "openai", "local", "mcp"],
+        help="AI backend to use (default: claude)",
     )
     parser.add_argument("--api-key", default=None, help="API key (claude/openai); falls back to env var")
-    parser.add_argument("--model", default=None, help="Override default model for claude/openai backends")
-    parser.add_argument("--ricky-url", default="http://localhost:8000/mcp", help="Ricky MCP server URL (llama backend)")
-    parser.add_argument("--mcp-url", default="http://localhost:8001/mcp", help="MCP server URL (mcp backend)")
+    parser.add_argument("--model", default=None, help="Override default model for claude/openai/local backends")
+    parser.add_argument("--mcp-url", default="http://localhost:8001/mcp", help="MyCode MCP server URL (mcp backend)")
+    parser.add_argument("--llm-url", default="http://localhost:8080/v1", help="Base URL of a local OpenAI-compatible LLM server (local backend)")
     parser.add_argument("--timeout", type=int, default=120, help="Request timeout in seconds (default: 120)")
     parser.add_argument("--profile", default=str(DEFAULT_PROFILE))
 

{mycode_aiagent-0.4.1 → mycode_aiagent-0.4.3}/mycode_aiagent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-aiagent
-Version: 0.4.1
+Version: 0.4.3
 Summary: Style-aware code generation — analyze any codebase and generate new code that matches its style
 License: MIT
 Project-URL: Homepage, https://github.com/RyanAbbottData/MyCode
@@ -90,16 +90,29 @@ MyCode delegates inference to a pluggable backend. Choose one based on what you
 
 | Backend | Flag | Requirement |
 |---|---|---|
-| Local LLM | `--backend llama` (default) | MCP server running at `localhost:8000` |
-| Anthropic Claude | `--backend claude` | `ANTHROPIC_API_KEY` env var or `--api-key` |
+| Anthropic Claude | `--backend claude` (default) | `ANTHROPIC_API_KEY` env var or `--api-key` |
 | OpenAI | `--backend openai` | `OPENAI_API_KEY` env var or `--api-key` |
-| MyCode server | `--backend mcp` | A running MyCode MCP server at `--mcp-url` |
+| Local LLM (OpenAI-compatible) | `--backend local` | LLM server at `--llm-url` (default: `http://localhost:8080/v1`) |
+| Any MCP server | `--backend mcp` | A running MyCode MCP server at `--mcp-url` |
 
 When `--backend mcp` is used with `analyze` or `generate`, the CLI delegates the entire operation to the running MyCode server — it calls the server's `analyze_codebase` or `generate_code` tool directly instead of running the pipeline locally. This is the recommended way to use MyCode in a multi-project or agentic setup.
 
 ### Setting up a local LLM
 
-The `llama` backend expects an MCP server at `http://localhost:8000/mcp` that exposes two tools: one for code generation and one for analysis. Any MCP-compatible wrapper around a local model will work. Here is a recommended setup using [llama.cpp](https://github.com/ggerganov/llama.cpp):
+Use `--backend local` to connect MyCode directly to any OpenAI-compatible LLM server (llama.cpp, LM Studio, Ollama, etc.) — no wrapper needed. Point `--llm-url` at the server's `/v1` base URL:
+
+```bash
+# Start your local LLM server (example: llama.cpp)
+python -m llama_cpp.server --model ./models/codellama-7b-instruct.Q4_K_M.gguf --port 8080
+
+# Analyze using the local LLM directly
+my-code --backend local --llm-url http://localhost:8080/v1 analyze ./my_project
+
+# Or start a MyCode MCP server backed by your local LLM
+my-code --backend local --llm-url http://localhost:8080/v1 serve --port 8000 --daemon
+```
+
+If you need a full MCP-wrapped setup instead (e.g. the local LLM exposes only `/v1/completions` without chat completions), here is a recommended pattern using [llama.cpp](https://github.com/ggerganov/llama.cpp):
 
 **1. Download a model**
 
@@ -126,7 +139,7 @@ python -m llama_cpp.server \
 
 **3. Wrap it with an MCP server**
 
-The `llama` backend communicates over MCP, not directly with the llama.cpp HTTP API. You need a thin MCP wrapper that exposes two tools:
+The `mcp` backend communicates over MCP, not directly with the llama.cpp HTTP API. You need a thin MCP wrapper that exposes two tools:
 - A **code generation tool** (name must not contain `"analyze"`)
 - An **analysis tool** (name must contain `"analyze"`)
 
@@ -168,13 +181,13 @@ python llm_mcp_server.py
 **4. Point MyCode at it**
 
 ```bash
-my-code --backend llama --ricky-url http://localhost:8000/mcp analyze .
+my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze .
 ```
 
 Or set a custom URL if your server runs on a different port:
 
 ```bash
-my-code --backend llama --ricky-url http://localhost:9000/mcp analyze .
+my-code --backend mcp --mcp-url http://localhost:9000/mcp analyze .
 ```
 
 ---
@@ -198,6 +211,7 @@ Using a different backend:
 ```bash
 my-code --backend claude analyze ./path/to/codebase
 my-code --backend openai --api-key sk-... analyze ./path/to/codebase
+my-code --backend local --llm-url http://localhost:8080/v1 analyze ./path/to/codebase
 ```
 
 The profile is saved to `style_profile.json` by default. Specify a different path with `--profile`:
@@ -240,11 +254,11 @@ my-code --backend mcp --mcp-url http://localhost:8000/mcp generate "write a rate
 my-code [OPTIONS] COMMAND
 
 Options:
-  --backend {llama,claude,openai,mcp}   AI backend to use (default: llama)
+  --backend {claude,openai,local,mcp}    AI backend to use (default: claude)
   --api-key TEXT                         API key for claude/openai backends
   --model TEXT                           Override the default model
-  --ricky-url TEXT                       Local LLM MCP server URL (default: http://localhost:8000/mcp)
-  --mcp-url TEXT                         Custom MCP server URL (default: http://localhost:8001/mcp)
+  --mcp-url TEXT                         MyCode MCP server URL (mcp backend, default: http://localhost:8001/mcp)
+  --llm-url TEXT                         Base URL of a local OpenAI-compatible LLM server (local backend, default: http://localhost:8080/v1)
   --profile TEXT                         Path to style profile JSON (default: style_profile.json)
 
 Commands:
@@ -274,9 +288,10 @@ from my_code import StyleAnalyzer, generate_code, make_backend
 from pathlib import Path
 
 # Create a backend
-backend = make_backend()                           # local LLM (default)
-backend = make_backend("claude")                   # Claude (reads ANTHROPIC_API_KEY)
-backend = make_backend("openai", api_key="sk-...") # OpenAI
+backend = make_backend("claude")                                              # Claude (reads ANTHROPIC_API_KEY)
+backend = make_backend("openai", api_key="sk-...")                            # OpenAI (GPT models)
+backend = make_backend("local", llm_url="http://localhost:8080/v1")           # Local LLM (OpenAI-compatible)
+backend = make_backend("mcp",   mcp_url="http://localhost:8000/mcp")          # Delegate to a MyCode server
 
 # Analyze a codebase
 analyzer = StyleAnalyzer(backend)
@@ -328,15 +343,15 @@ MyCode can expose itself as an MCP server so any MCP-compatible agent or orchest
 ### Quick start
 
 ```bash
-# Local LLM backend (default) — foreground, blocks until Ctrl-C
-my-code serve
-
-# Claude backend
+# Claude backend — foreground, blocks until Ctrl-C
 my-code --backend claude serve --port 8080
 
 # OpenAI backend
 my-code --backend openai serve --port 8080
 
+# Local LLM (OpenAI-compatible server on port 8080)
+my-code --backend local --llm-url http://localhost:8080/v1 serve --port 8000
+
 # Bind on all interfaces
 my-code --backend claude serve --host 0.0.0.0 --port 8080
 ```
@@ -379,8 +394,8 @@ my-code stop --pid-file mycode-8081.pid
 Start a MyCode server as a daemon, then point `analyze` and `generate` at it with `--backend mcp`. The CLI calls the server's tools directly — the server handles all analysis and generation using whichever LLM it was started with.
 
 ```bash
-# Start the server (uses a local LLM at port 8001 as its brain)
-my-code --backend mcp --mcp-url http://localhost:8001/mcp serve --daemon --port 8000
+# Start the server backed by a local LLM
+my-code --backend local --llm-url http://localhost:8080/v1 serve --daemon --port 8000
 
 # Analyze a codebase via the server
 my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze ./my_project
@@ -476,7 +491,6 @@ my_code/
 ├── cli.py               # CLI entry point (my-code command)
 ├── backends/
 │   ├── base.py          # AIBackend abstract base class
-│   ├── ricky_backend.py # Local LLM backend (connects via MCP)
 │   ├── claude_backend.py
 │   ├── openai_backend.py
 │   └── mcp_backend.py   # Generic MCP server backend

{mycode_aiagent-0.4.1 → mycode_aiagent-0.4.3}/mycode_aiagent.egg-info/SOURCES.txt

@@ -12,7 +12,6 @@ my_code/backends/base.py
 my_code/backends/claude_backend.py
 my_code/backends/mcp_backend.py
 my_code/backends/openai_backend.py
-my_code/backends/ricky_backend.py
 my_code/utils/__init__.py
 my_code/utils/prompts.py
 mycode_aiagent.egg-info/PKG-INFO

{mycode_aiagent-0.4.1 → mycode_aiagent-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mycode-aiagent"
-version = "0.4.1"
+version = "0.4.3"
 description = "Style-aware code generation — analyze any codebase and generate new code that matches its style"
 readme = "README.md"
 requires-python = ">=3.10"

mycode_aiagent-0.4.1/my_code/backends/ricky_backend.py

@@ -1,15 +0,0 @@
-from .base import AIBackend
-from ..mcp_client import MCPClient
-
-
-class RickyBackend(AIBackend):
-    max_file_chars: int = 1500
-
-    def __init__(self, url: str = "http://localhost:8000/mcp", timeout: int = 120):
-        self._client = MCPClient(url=url, timeout=timeout)
-
-    def ask_for_code(self, prompt: str) -> str:
-        return self._client.ask_for_code(prompt)
-
-    def ask_to_analyze(self, prompt: str) -> str:
-        return self._client.ask_to_analyze(prompt)