Product Paper

Knixus QA and Test Tool Sets

mcp-loc

Where knix-doc is your AI agents' memory, mcp-loc is their hands. An ever-expanding, permission-controlled toolbox of 80+ tools spanning QA automation, visual testing, multi-language runtimes, and web operations — all governed from a single admin panel, shaped to every agent's role.

Playwright Selenium cURL pytest git Python Ruby Node.js Java CSS Audit JS Test Lighthouse axe-core Visual Diff API Test Web Fetch

Get in Touch See Full Arsenal

80+

Total Tools

Across 8 specialized groups

100%

Permission Gated

Every call validated per tenant

Agent Roles

Unlimited custom configurations

Admin Panel

knix-doc controls everything

Philosophy

The Swiss Army Knife of Enterprise AI Development

Most MCP servers give AI agents the ability to read. mcp-loc gives them the ability to act — with precision, control, and the full breadth of a seasoned engineer's toolbox.

Every tool in mcp-loc is permission-gated at the tenant level through the knix-doc admin panel. This means the same infrastructure that manages your knowledge base also governs your execution capabilities — a single, coherent control plane for your entire AI agent ecosystem.

Role-First Design A QA agent gets test runners. A developer gets git and build tools. A PM gets read-only access. Every agent operates with exactly what its role demands — nothing more, nothing less.

Built to Grow New tool groups are added continuously. The permission framework automatically extends to cover every new capability — your governance model never needs to be rebuilt as the arsenal expands.

Deeply Integrated with knix-doc mcp-loc isn't a standalone server — it's the execution arm of the knix-doc ecosystem. Documentation, permissions, tenants, and tool access all flow through one unified platform.

Platform Architecture

knix-doc Admin Panel Tenant · Permission · Collection management

↓

Controls permissions for both platforms

knix-doc RAG · Search · Redmine

mcp-loc QA · Run · Design · Git

↓

MCP Protocol · Per-tenant tool access

Dev

Analyst

Reviewer

Full Arsenal

Every Tool a Professional Engineer Needs

Eight specialized tool groups covering the complete development and QA lifecycle. Each group is independently permission-controlled, assignable per tenant, and designed for professional-grade usage.

~35 tools

qa_tools

Full-stack QA automation suite. Browser automation, API testing, headless execution, accessibility checks, and performance profiling.

Playwright Selenium cURL pytest axe-core Lighthouse + more

~20 tools

design_tools

CSS and JavaScript visual quality control. Visual regression, style auditing, responsiveness testing, and UI consistency validation.

Visual Diff CSS Audit JS Coverage Percy Responsive + more

~12 tools

run_python_tools

Execute Python scripts, run test suites, manage virtual environments, and inspect outputs — fully controlled and sandboxed.

python exec pytest pip coverage lint

~10 tools

run_ruby_tools

Ruby script execution, RSpec test runner, Bundler dependency management, and Rails command support for backend teams.

ruby exec rspec bundler rubocop rails

~10 tools

run_node_tools

Node.js script execution, npm/yarn task runners, Jest and Mocha test frameworks, and ESLint code quality checks.

node exec npm run jest eslint tsx

~8 tools

run_java_tools

Java compilation, Maven/Gradle build execution, JUnit test runner, and static analysis for enterprise Java workloads.

javac maven gradle junit checkstyle

~8 tools

mcp_loc_git_tools

Full git workflow integration. Diff, stage, commit, log, branch operations — enabling autonomous development loops with full version control.

git diff git commit git log git status git branch

~6 tools

mcp_loc_web_tools

Web search and page fetch for research-driven development. Bring external documentation and API specs directly into any coding session.

web search page fetch API probe screenshot

QA Automation

The Complete QA Pipeline, in Every Agent Session

qa_tools brings 35 professional-grade testing instruments into the MCP ecosystem. From headless browser automation to accessibility auditing, it covers every dimension of modern software quality — without leaving the AI coding environment.

Browser Automation: Playwright & Selenium Full headless browser control for end-to-end testing. Agents can write and execute test scenarios, capture screenshots, interact with SPAs, and validate UI behavior across multiple browsers.

Permission-Controlled cURL HTTP testing with fine-grained URL allowlists. Define exactly which endpoints agents can call, which HTTP methods are permitted, and which parameters are allowed — enterprise-safe API testing without open-ended shell access.

Accessibility & Performance Auditing axe-core accessibility checks and Lighthouse performance scoring run automatically as part of any test cycle — ensuring quality standards are met before code ever reaches review.

Automated Test Reporting to Redmine QA agents can write test results directly back to Redmine issues via knix-doc's redmine_tools — closing the loop between test execution and issue tracking without any manual handoff.

qa_tools · Automated Test Cycle

mcp-loc · qa_tools executor

→ playwright test checkout.spec.ts
Running 4 tests using 2 workers

✓ checkout > renders cart items [312ms]
✓ checkout > applies discount code [487ms]
✓ checkout > payment gateway redirect [891ms]
! checkout > mobile viewport layout [203ms]
→ Accessibility: 2 WCAG 2.1 AA violations

→ axe-core --url http://localhost:3000/checkout
✗ color-contrast button.pay-now: ratio 2.4:1 (min 4.5)
✗ label input#cvv: missing aria-label

→ redmine_add_comment issue=#472
✓ QA report posted · 2 issues flagged

cURL URL Permission Configuration

GET api.internal.corp/v1/orders/* Allow

POST api.internal.corp/v1/payments Params limited

* external-service.io/* Denied

Visual Quality

Visual Correctness Is Not Optional

design_tools closes the gap that traditional code testing leaves open: visual quality. CSS integrity, JavaScript behavior, responsive layouts, and pixel-level visual regression — all automated, all agent-accessible.

Visual Regression Testing Screenshot-based before/after comparison at pixel level. Agents detect unintended UI changes caused by CSS refactoring or dependency updates before they reach production.

CSS Integrity Auditing Detect unused styles, specificity conflicts, broken custom properties, and responsive breakpoint failures. AI agents can suggest and apply targeted CSS improvements with full validation.

JavaScript Coverage & Behavior Testing Measure JavaScript coverage, detect dead code paths, and validate runtime behavior through headless execution — ensuring UI logic is as rigorously tested as backend logic.

Cross-Device Responsiveness Validation Automated layout verification across predefined viewport profiles. Mobile, tablet, and desktop breakpoints tested in a single agent action — no manual browser resizing ever needed.

design_tools · Visual Audit Report

Before

After (diff detected)

Δ 4.2%

→ css_audit --path src/styles/checkout.css
⚠ 12 unused selectors (3.1 KB dead CSS)
⚠ specificity conflict .btn-pay vs button.primary
✓ custom properties all resolved

→ responsive_check --viewports mobile,tablet,desktop
✓ desktop 1440px ✓ tablet 768px
✗ mobile 375px overflow on payment form

Polyglot Execution

One Platform. Every Language Your Team Uses.

Modern enterprises don't run on a single language. Python services, Ruby backends, Node microservices, Java enterprise apps — they all coexist. mcp-loc's runtime tool groups give AI agents the same execution breadth that human engineers have, with the same permission controls applied consistently across all of them.

Python — run_python_tools pytest, coverage, lint, pip management, virtual environment operations. The most complete Python development loop available to any AI agent.

Ruby — run_ruby_tools RSpec, Bundler, RuboCop, Rails commands. Enterprise Ruby and Rails applications fully testable by AI agents without custom integrations.

Node.js — run_node_tools Jest, Mocha, ESLint, npm/yarn script execution. Frontend and full-stack Node.js applications tested and validated through the same MCP interface as everything else.

Java — run_java_tools Maven, Gradle, JUnit, Checkstyle. Enterprise Java workloads integrated into the AI agent workflow — build, test, and validate without leaving the session.

mcp-loc · Polyglot CI Loop

# Python microservice
→ run_python pytest services/payment/ -v
PASSED 14/14 coverage: 91.3%

# Ruby auth service
→ run_ruby bundle exec rspec spec/auth/
14 examples, 0 failures

# Node.js frontend
→ run_node npm run test:unit
PASS src/components/Checkout.test.tsx
PASS src/hooks/usePayment.test.ts

# Java payment-core
→ run_java mvn test -pl payment-core
Tests run: 47, Failures: 0

────────────────────────────────
✓ All services green → ready to merge

Role Assignment

Every Agent Gets Exactly What It Needs

The same tool that makes a QA agent powerful could be a security risk in a PM agent's hands. mcp-loc's tenant-based permission system ensures every role operates with a precisely tailored toolset — configured once, enforced on every call.

Developer Agent

Full execution authority

The broadest toolset. Write code, run it in any language, commit to git, search documentation, test against real endpoints, and update Redmine — the complete developer workflow in a single agent session.

run: all langs git: full web: full qa: full

QA Agent

Test, validate, report

Full access to qa_tools and design_tools. Can execute tests across all runtimes, run Playwright and Selenium suites, perform visual diffs, and post results directly to Redmine. No write access to production code.

qa_tools: full design_tools: full run: test-only git: read

Project Manager Agent

Oversight without execution

Web tools for research, read-only git access for progress tracking, and Redmine full access for issue management. No shell execution — the PM role never touches a runtime.

web: full git: read run: none qa: none

Analyst Agent

Insight without risk

Web tools and read-only Python for data analysis. Can run analytical scripts against approved datasets, search internal docs, and generate structured reports — no write or test execution permissions.

web: full run_python: analysis git: read qa: none

Code Reviewer Agent

Review without execution

Git diff and log tools for code inspection, lint tools for style validation, read-only doc search, and Redmine commenting. Reviews changes thoroughly without ever running untrusted code.

git: diff+log lint: all run: none web: read

Your Custom Role

Any combination, any time

Mix and match tool groups freely. Define roles that match your team's actual structure — not a predefined template. Change it live from the admin panel whenever your workflow evolves.

Get Started

Give Your AI Agents
a Craftsman's Toolbox.

mcp-loc is the execution layer that transforms AI agents from knowledge consumers into true development participants — testing, building, validating, and delivering, with the precision and safety your organization demands.

mcp-loc works best when paired with knix-doc — both governed from the same admin panel, both serving the same agent ecosystem.