# Customization
## Adding Your Own LLM Provider
### MCP Server Template
Create a new server following this template:
```javascript
#!/usr/bin/env node
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { spawn } from "child_process";
function log(msg) {
console.error(`[YourLLM MCP] ${msg}`);
}
function detectError(output) {
const text = output.toLowerCase();
// Add your provider-specific error patterns
if (text.includes("rate limit") || text.includes("quota")) {
return {
isError: true,
errorType: "QUOTA_EXCEEDED",
message: "YourLLM quota exceeded.",
};
}
if (text.includes("unauthorized") || text.includes("invalid key")) {
return {
isError: true,
errorType: "AUTH_ERROR",
message: "YourLLM auth failed. Check credentials.",
};
}
return null;
}
function runLLM(prompt, options = {}) {
const { timeoutMs = 90000 } = options;
return new Promise((resolve, reject) => {
const proc = spawn("your-cli-tool", ["-p", prompt], {
stdio: ["pipe", "pipe", "pipe"],
env: { ...process.env },
});
let stdout = "";
let stderr = "";
let killed = false;
const timer = setTimeout(() => {
killed = true;
proc.kill("SIGTERM");
setTimeout(() => {
try { if (!proc.killed) proc.kill("SIGKILL"); } catch {}
}, 5000);
}, timeoutMs);
proc.stdout.on("data", (d) => { stdout += d.toString(); });
proc.stderr.on("data", (d) => { stderr += d.toString(); });
proc.stdin.end();
proc.on("close", (exitCode) => {
clearTimeout(timer);
if (killed) reject(new Error(`Timeout after ${timeoutMs/1000}s`));
else resolve({ stdout, stderr, exitCode });
});
proc.on("error", (err) => {
clearTimeout(timer);
reject(err);
});
});
}
const mcpServer = new McpServer({
name: "yourllm-mcp",
version: "1.0.0",
});
mcpServer.registerTool(
"yourllm_chat",
{
description: "Send a prompt to YourLLM",
inputSchema: {
prompt: z.string().describe("The prompt to send"),
timeout: z.number().default(90).describe("Timeout in seconds"),
},
},
async ({ prompt, timeout = 90 }) => {
try {
log(`Chat: ${prompt.length} chars`);
const startTime = Date.now();
const { stdout, stderr } = await runLLM(prompt, {
timeoutMs: timeout * 1000,
});
const combined = stdout + stderr;
const error = detectError(combined);
if (error) {
return { content: [{ type: "text", text: error.message }], isError: true };
}
const response = stdout.trim();
if (!response) {
return { content: [{ type: "text", text: "No response" }], isError: true };
}
const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
log(`OK in ${elapsed}s`);
return { content: [{ type: "text", text: response }] };
} catch (error) {
const known = detectError(error.message);
if (known) return { content: [{ type: "text", text: known.message }], isError: true };
return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
}
}
);
async function main() {
const transport = new StdioServerTransport();
await mcpServer.connect(transport);
log("Started and ready");
}
main().catch(console.error);
```
### Package.json Template
```json
{
"name": "@claude-concilium/mcp-yourllm",
"version": "1.0.0",
"description": "MCP server for YourLLM",
"main": "server.js",
"bin": { "mcp-yourllm": "./server.js" },
"type": "module",
"license": "MIT",
"dependencies": {
"@modelcontextprotocol/sdk": "^1.20.2",
"zod": "^3.25.76"
}
}
```
## Modifying the Fallback Chain
The fallback chain is defined in the Concilium skill (`skill/ai-concilium.md`). Edit the protocol section to change the order:
```
# Default chain:
OpenAI → Qwen → DeepSeek
Gemini → Qwen → DeepSeek
# Example: Add your LLM as first fallback:
OpenAI → YourLLM → Qwen → DeepSeek
Gemini → YourLLM → Qwen → DeepSeek
```
Update the skill's "Error Handling" section accordingly.
## Custom Prompt Strategies
### Code Review (default)
Both agents get the same diff with slightly different framing:
- Agent A: brief description + key changes
- Agent B: full diff + detailed context
### Architecture Decision
Ask different questions to different agents:
- Agent A: "What are the tradeoffs of approach X vs Y?"
- Agent B: "Design a solution for [problem] given [constraints]"
### Debugging
Provide the same error context but ask for different analysis:
- Agent A: "What could cause this error? List top 3 hypotheses."
- Agent B: "Trace the code path that leads to this error. What's wrong?"
## Adjusting Timeouts
Default timeouts are set per tool. Override in your MCP calls:
```
mcp__openai__openai_chat:
prompt: "..."
timeout: 180 # Override default 90s for complex prompts
```
For large codebases, use `gemini_analyze` with its 180s default (can be increased further).
