You can use DeepSeek models with 1PC through OpenCode, an AI client that connects to remote MCP servers. OpenCode supplies the connection and tools; DeepSeek supplies the model; 1PC supplies saved product knowledge, decisions, progress and workflow guidance.
This guide helps a solo founder connect those parts, read the current product state and verify that an authorized save survives a fresh conversation. The configuration follows official documentation checked on October 4, 2026; the steps below are a verification procedure, not a report of a completed live connection.
Choose the client route
Use the OpenCode installation instructions and a DeepSeek API account. DeepSeek's OpenCode integration guide recommends version 1.18.30 or later for its documented setup. Start OpenCode, run /connect, select DeepSeek and enter your API key in the credential prompt. Use /models to select an available DeepSeek model, following the OpenCode provider guide.
This route uses the DeepSeek API rather than a connector inside DeepSeek's chat website. DeepSeek's Responses API compatibility table lists built-in mcp tools as ignored. A client must handle MCP separately. Access to a model, a working 1PC connection and permission to write are separate checks.
You also need a 1PC account and permission to access the intended product. Free access includes Product Owner state and routing; paid workflow guidance and private skill loading follow your 1PC plan. Model API usage is handled by your provider account. For the connection overview, see the 1PC MCP server.
Connect OpenCode to 1PC
Create and verify your 1PC account, then create a personal access token in MCP connections. It grants full User access, expires after 90 days and can be revoked. Use that token in the bearer-header configuration below and keep it in secret storage. The account connection guide covers OAuth and personal tokens. Use the same account for existing saved work; account setup does not configure OpenCode or prove a live connection.
Set ONEPC_MCP_TOKEN in the environment of the process that starts OpenCode. For Bash or Zsh, this prompt reads the token without putting its value in the command history:
printf '1PC token: '
read -r -s ONEPC_MCP_TOKEN
printf '\n'
export ONEPC_MCP_TOKEN
Run opencode --version. Merge the matching example into opencode.json in the directory where you run OpenCode, preserving existing settings. Environment values use {env:NAME} interpolation; the JSON contains no token value.
OpenCode 1.x
The 1.x remote MCP reference places each server directly under mcp.
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"onepc": {
"type": "remote",
"url": "https://use1pc.com/mcp",
"oauth": false,
"headers": {
"Authorization": "Bearer {env:ONEPC_MCP_TOKEN}"
}
}
}
}
OpenCode 2.x
The 2.x MCP reference uses mcp.servers. Use this alternative when your installation uses that schema.
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"servers": {
"onepc": {
"type": "remote",
"url": "https://use1pc.com/mcp",
"oauth": false,
"headers": {
"Authorization": "Bearer {env:ONEPC_MCP_TOKEN}"
}
}
}
}
}
Restart OpenCode from the shell with the exported token and run opencode mcp list. Check the actual connection status before continuing. This example uses bearer authentication. For OAuth, 1PC supports discovery and consent, but the client's callback and resource handling need verification against the 1PC authentication requirements. Do not mix personal-token headers with an OAuth example.
Enter Product Owner before product work
Adding an MCP server makes tools available; it does not install the 1PC plugin's native Product Owner skill. Tell the assistant to enter through Product Owner and load current backend guidance. Start with a read-only request:
Use the onepc MCP connection. Before this product workflow, call
get_skill_instructions with skill_id "product-owner", phase "entry".
Follow the returned requirements and applicable checks. Read workspace
context, paginate the skill catalog and accessible products, and resolve
the product I mean. Keep product_id explicit after selection.
For Follow-up Board, read current product context, relevant saved files,
accepted decisions and progress. Explain the current state and relevant
gaps before proposing work. If the product is
ambiguous, ask me to choose it. Do not save or create anything yet.
Follow-up Board is a fictional example. Replace it with your product's name. If no product exists, bring your experience, a problem or a rough idea. Let the assistant compare accessible products before you confirm reuse or creation with a working name.
Inspect the client's tool activity. An answer based only on the prompt has not verified saved state. For execution, Product Owner selects an available catalog skill, loads get_skill_instructions with its skill_id and phase work, and uses the returned Markdown with its separate requirements. It then loads product context for that skill. Tool-delivered guidance does not register a native host skill.
For recurring use, place the entry instruction in a dedicated local instruction file and load it using your version's supported rules mechanism. OpenCode 1.x documents an instructions file list in its configuration reference. Keep credentials and product facts out of that file; fetch changing requirements and state at runtime. A fresh session still needs the entry check.
Choose a bounded founder task
After the state read, try one decision-sized job. Suppose your saved goal is helping freelance designers notice unanswered proposals, and you have six hours available this week:
Based on the saved state you just read, compare the most relevant next
actions for my six available hours. Recommend one action, state what waits,
and identify missing evidence. Reuse current accepted decisions and work.
Keep this review in the conversation until I approve what should be saved.
The weekly product review worksheet explains the method. OpenCode is a coding client, but this request is a product review: repository changes need their own scope. A written plan does not prove a feature works or a customer gets value.
If your next action is a feature launch, use the shared feature launch marketing plan. Product Owner can surface related marketing work; a suggestion does not automatically authorize content publication, customer contact or another workflow.
Save and verify continuity
Choose the authorized Product, Feature, Version or Task scope, department, document role and stable key before saving. Inspect the current revision, prepare and self-review the update, then verify its commit receipt. Domain guidance and website editing remain subject to the selected plan.
Save the review we approved as scoped Knowledge for this selected
product, using the agreed department, reference role and stable key. Preserve
existing valid information. Use the file revision you read, verify the
save receipt, then read the saved file back. Report its actual saved path
and revision, and separate the proposed next action from accepted work.
Only claim success after the actual receipt and read-back. Prepare and self-review each scoped Knowledge or Task update, then commit with its exact revision and current Task claim where required. On a revision conflict, reload current content and recovery guidance instead of overwriting it.
Open a fresh conversation using the same 1PC account, then repeat the Product Owner entry instruction. Give it the selected product and the actual path returned by the save:
Enter Product Owner again through onepc. For the selected product, read
the saved review at the path I provide and its current revision. Explain
what was saved, what remains proposed and what has changed in current
state. Do not rerun the review or modify anything.
A matching read-back demonstrates this persistence check. It does not establish identical recommendations across models. The cross-tool continuity guide explains what carries over: saved information, decisions and progress. Unsaved conversation details and host activity do not.
Check connection problems before rerunning work
- Authentication failure: verify the token is current and the OpenCode process received the environment variable. Replace expired or revoked credentials.
- Configuration error: use the server nesting for your installed major version. Check its official schema rather than combining examples.
- Tools listed, no product read: explicitly request Product Owner entry and inspect actual tool activity.
- Unavailable skill: inspect catalog availability and your 1PC plan. A working connection does not grant paid instructions.
- Unexpected write response: read the destination before retrying; an uncertain response may already have saved the file.
For detailed errors and write rules, use the MCP reference. To test removal of access, revoke this personal token in 1PC and verify that an authenticated read using it fails. Disconnecting a local configuration alone does not revoke a token.
Continue with one shared product record
Use the same workflow guides across compatible clients. If you have a repeatable review checklist, create and publish a private product skill; Product Owner can discover it when your account has access. Keep the method reusable and the product evidence in its saved context.
The practical setup goal is small: load the correct product, do a bounded piece of work, save it with permission and read it in a fresh session. Start with the 1PC MCP documentation and verify that loop before relying on the connection for larger deliverables.
Configure your 1PC connection
Use the MCP reference for authentication, tool schemas and save checks.
Open the MCP reference ↗