AI-powered POC Factory backend that turns requirements, proposals, and RFPs into validated AI and Physical AI proof-of-concepts with code, tests, documentation, deployment configurations, and optional GitHub blueprint intelligence.
POC Factory MCP Overview
Explore the POC Factory documentation and the installation guide. Select documentation and a deployment bundle matching the image tags you deploy.
Description:
POC Factory MCP is an AI-powered proof-of-concept generation system built on the NVIDIA NeMo Agent Toolkit. It accepts natural-language requirements, proposals, and RFPs, then produces working AI and Physical AI proofs of concept with code, tests, documentation, and deployment configuration. The MCP (Model Context Protocol) variant adds GitHub integration for intelligent blueprint discovery across curated NVIDIA blueprints, enabling automated matching of requirements to reference architectures. The container supports end-to-end POC lifecycle management: generation, validation, packaging, deployment, evaluation, optimization, monitoring, synthetic data generation, and model fine-tuning.
The container connects to an OpenAI-compatible inference provider. NVIDIA hosted inference is the default getting-started path, but deployments can use a supported self-hosted or third-party provider. The deployment configures inference roles for code, reasoning, balanced generation, fast tasks, and embeddings; models are external services and are not bundled in the container. No local GPU inference is required.
The container components are ready for commercial or non-commercial use.
License/Terms of Use:
GOVERNING TERMS: Your use of the container is governed by the NVIDIA Software License Agreement and Product-Specific Terms for AI Products. Your use of the model is governed by the NVIDIA Community Model License.
You are responsible for ensuring that your use of NVIDIA provided models complies with all applicable laws.
Deployment Geography:
Global
Program Classes:
The container uses the following configurable inference roles. The release bundle's env.example supplies the current model defaults; deployments can use compatible model mappings for their selected provider.
| Inference Role | Use Case | Configuration |
|---|---|---|
MODEL_CODE | POC scaffolding and implementation | OpenAI-compatible chat-completions model |
MODEL_REASONING | Requirements, architecture planning, and blueprint reranking | OpenAI-compatible chat-completions model |
MODEL_BALANCED | Drafting, proposals, and tool-calling assistants | OpenAI-compatible chat-completions model |
MODEL_FAST | Low-latency setup, synthetic generation, and high-volume checks | OpenAI-compatible chat-completions model |
MODEL_EMBEDDING | Blueprint semantic matching | Embeddings-capable model endpoint |
The container also includes the following supporting services:
| Service | Description | Port |
|---|---|---|
poc-factory-mcp | FastAPI backend — primary POC generation API | 8000 |
poc-factory-frontend | React single-page application and public entry point | 8080 (container), 80 (local host mapping) |
github-mcp-proxy | MCP proxy for GitHub blueprint intelligence | 8080 (Compose) or 8081 (Helm); internal only |
postgres | Persistent PostgreSQL database for multi-user state | 5432; private service only |
phoenix (optional) | OpenTelemetry-based observability and tracing | 6006, 4317 |
Deployment Details:
Supported Hardware Microarchitecture Compatibility:
- GPUs: Not required for container execution — all model inference is handled by an external compatible provider. A GPU is not needed on the host running this container.
- CPU: x86_64 (amd64) and ARM64 (arm64)
- Memory: Recommend minimum 8 GB RAM for the application stack
- Storage: Generated POCs are persisted to
./generated_pocs; recommend sufficient disk for POC output volume based on expected usage
Docker Compose Profiles:
| Profile | Services Included | Recommended For |
|---|---|---|
mcp | Environment preflight, backend, frontend, GitHub MCP proxy, and PostgreSQL | Standard recommended deployment |
full | mcp services plus Phoenix | Deployments requiring observability |
Required Deployment Values:
| Variable | Description |
|---|---|
NIM_NGC_ORG | NGC organization or namespace containing the published release images |
VERSION | Selected published image tag; keep all application images aligned with the deployment bundle |
POSTGRES_USER, POSTGRES_PASSWORD | PostgreSQL credentials required by Docker Compose |
ENCRYPTION_KEY | Stable Fernet-compatible key that encrypts saved inference, Cursor, and fine-tuning credentials |
INFERENCE_API_KEY, INFERENCE_BASE_URL, and all configured MODEL_* roles | Required for an administrator-managed inference profile; alternatively, enable user-provided inference profiles (BYOI) |
JWT_PRIVATE_KEY | PEM-encoded ES256 P-256 private key; required only when NGC_AUTH_ENABLED=true |
DATABASE_URL is constructed by the Docker Compose deployment from the PostgreSQL values above.
Optional Environment Variables:
| Variable | Default | Description |
|---|---|---|
GITHUB_TOKEN | — | Read-only token for authenticated GitHub MCP repository and blueprint lookups |
CODE_GENERATOR_TOOL | auto | Code generation mode: auto (contract-first), cursor, or llm |
CURSOR_API_KEY | — | Optional Cursor-assisted revisions; users can also supply a permitted credential in Settings |
ENABLE_PROMPT_CACHING | true | Enables repeated-context prompt caching |
ENABLE_POC_VALIDATION | true | Enables the automated quality validation pipeline |
POC_RETENTION_DAYS | 7 | Days before generated POCs are automatically cleaned up (0 = never) |
NGC_AUTH_ENABLED | Deployment-specific | Enables application authentication; enable for shared deployments and disable only for isolated local evaluation |
LOG_LEVEL | INFO | Application log level |
The validator acceptance threshold is configured by functions.code_validator.quality_threshold in the selected NAT YAML configuration (default 85). It is not controlled by a QUALITY_THRESHOLD environment variable.
Deployment:
To deploy using the recommended MCP profile:
Run these commands from the extracted matching NGC release bundle, in the directory containing docker-compose.yml, env.example, and scripts/validate-compose-env.sh.
Before starting, configure .env with NIM_NGC_ORG=nvidia for the NVIDIA catalog and VERSION set to the selected image tag. For internal copies, use NIM_NGC_ORG=nvstaging/sae-poc-factory or NIM_NGC_ORG=1042542912482436 (SAE-PoC-Factory), with credentials authorized for that namespace. Choose an available release tag and keep all POC Factory images on the same version. If set, POC_FACTORY_MCP_VERSION, GITHUB_MCP_PROXY_VERSION, and FRONTEND_VERSION override VERSION; update or remove those overrides when upgrading.
Set PostgreSQL credentials and a stable ENCRYPTION_KEY in .env, following the generation instructions in env.example. Configure an administrator-managed inference profile, or allow users to supply their own profiles in Settings. For shared deployments, enable NGC_AUTH_ENABLED and supply the required ES256 JWT_PRIVATE_KEY. An optional read-only GITHUB_TOKEN enables authenticated source discovery. Put deployment values in .env so both Compose and its launch preflight receive them.
For upgrades, preserve the existing .env, encryption key, database credentials, and persistent data volumes. Back up the data before changing versions, and review the matching release documentation for any additional upgrade steps. Generate an encryption key only for a new deployment; replacing it makes previously saved credentials undecryptable.
# From the extracted matching NGC release bundle
# Create .env only for a new deployment; preserve an existing file
test -f .env || cp env.example .env
# Edit .env with the image namespace, release tag, and settings described above
# Authenticate with an NGC API key authorized to pull these images
# Enter the API key at the password prompt
docker login nvcr.io --username '$oauthtoken'
# Validate the Compose configuration, then pull and start the standard stack
docker compose --profile mcp config --quiet
docker compose --profile mcp pull
docker compose --profile mcp up -d
# Or add Phoenix observability
docker compose --profile full up -d
The application API will be available at http://localhost:8000. Health status can be verified at http://localhost:8000/health.
NVIDIA hosted inference is available through the default INFERENCE_BASE_URL, but POC Factory also supports compatible self-hosted and third-party inference providers. Verify that chat roles support /chat/completions and that MODEL_EMBEDDING supports /embeddings.
Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA’s hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.
Reference(s):
Security Common Vulnerabilities and Exposures (CVEs)
Please review the Security Scanning tab on NGC to view the latest security scan results. For certain open-source vulnerabilities listed in the scan results, NVIDIA provides a response in the form of a Vulnerability Exploitability eXchange (VEX) document. The VEX information can be reviewed and downloaded from the Security Scanning tab.
Ethical Considerations:
NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. Developers should work with their internal developer team to ensure these software components meet requirements for the relevant industry and use case and address unforeseen product misuse.
Please report quality, risk, security vulnerabilities or NVIDIA AI Concerns here.
Get Help
Getting Started with POC Factory MCP
Use the documentation and installation guide above for deployment instructions.
Enterprise Support
Get access to knowledge base articles and support cases or submit a ticket.