> For the complete documentation index, see [llms.txt](https://wayfinder-1.gitbook.io/wayfinder/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://wayfinder-1.gitbook.io/wayfinder/sdk-setup/quickstart.md).

# Quickstart

> **Most users don't need this page.** The fastest way to use Wayfinder is to [provision a Shell](/wayfinder/shells/getting-started.md) — no installation, no config files. The steps below are for developers who want to run the SDK locally.

Clone the repo, open it in your coding agent, and let the agent set everything up from a single prompt — dependencies, config, and dev wallets. No Python knowledge required.

GitHub repo: <https://github.com/WayfinderFoundation/wayfinder-paths-sdk>

### Supported coding agents

| Agent       | Open the repo                      |
| ----------- | ---------------------------------- |
| Claude Code | `claude` (in the repo directory)   |
| Codex       | `codex` (in the repo directory)    |
| Opencode    | `opencode` (in the repo directory) |

Any MCP-compatible coding agent will work — the SDK ships with `.mcp.json` and `AGENTS.md` for automatic setup.

## 1) Clone + open your coding agent

```bash
git clone https://github.com/WayfinderFoundation/wayfinder-paths-sdk
cd wayfinder-paths-sdk
# Open in your coding agent of choice
```

## 2) Let your agent set it up

Paste this into your coding agent:

```
Set up the Wayfinder Paths SDK in this repo: run the bootstrap script, create my config and local dev wallets, then tell me what's left to do — where to get an API key and which wallets to fund.
```

The agent handles the whole bootstrap for you. It reads the `AGENTS.md` and `.mcp.json` that ship with the repo, runs the setup script, and reports back what's left — so you don't need to know Python or Poetry.

CLI: prefer to run it yourself? It's one command.

```bash
python3 scripts/setup.py
```

Either way, the bootstrap installs Poetry + dependencies, creates `config.json` (from `config.example.json`), writes `.mcp.json`, and adds local dev wallets (`main` + per-strategy labels).

## 3) Add an API key

Your API key is the one thing you add by hand — keep secrets out of the chat.

1. Go to `https://wayfinder.ai/`
2. Connect your wallet and create an API key (found in Settings)
3. Paste it into `config.json` under `system.api_key` (or export `WAYFINDER_API_KEY`)

## 4) Fund your wallets

Ask the agent where to send funds:

```
What are my wallet addresses, and what should I fund them with to run a strategy?
```

It reads the addresses from `config.json` and tells you the gas and assets each chain needs. Then fund the `main` wallet — and any strategy wallet you plan to run — from your own wallet. Wallets live in `config.json` under `wallets[]`; keep this file private.

## 5) Enable the MCP server

When your agent asks, approve the project MCP server (from `.mcp.json`). That's what gives it the Wayfinder tools.

## 6) Verify it's working

Try prompts like:

* "Show me available strategies" (calls `core_get_adapters_and_strategies`)
* "Show me my wallet balances" (calls `core_get_wallets`)
* "Quote swapping 100 USDC to ETH on Arbitrum" (calls `onchain_quote_swap`)

## Example prompts

These examples assume you have a `main` wallet in `config.json` and you've funded it on the relevant chains.

### What's in my wallet?

```
What's in my wallet?
```

Your agent calls `core_get_wallets` and gives you a multi-chain breakdown (no funds move).

### Swap USDC (Arbitrum) → PROMPT (Base)

```
Swap 100 USDC on Arbitrum for PROMPT on Base.
First show me the quote, then ask for confirmation before executing.
```

### Check ETH funding on Hyperliquid

```
Check the current ETH funding rate on Hyperliquid and tell me if it's positive or negative.
```

### Polymarket: portfolio + redeem

```
Show me my Polymarket portfolio. If anything is resolved and redeemable, ask before redeeming it.
```

### Buy wstETH + short ETH perp

```
If ETH funding on Hyperliquid is positive:
1) Swap 100 USDC on Base into wstETH.
2) Short $100 notional ETH perp on Hyperliquid at 2x cross leverage.
Ask for confirmation before each fund-moving step, then show me how to verify positions.
```

### Deposit to a strategy

```
Deposit 100 USDC into the Moonwell wstETH loop strategy and then show me status.
Ask for confirmation before any fund-moving action.
```

## Strategy lifecycle

Most strategies implement four actions:

1. **status** — read-only portfolio snapshot
2. **deposit** — move funds into the strategy
3. **update** — deploy/rebalance/harvest
4. **withdraw / exit** — unwind positions and return funds

Walk through the lifecycle with your agent:

```
Show me the status of the stablecoin yield strategy.
```

```
Deposit 100 USDC into the stablecoin yield strategy. Ask before executing.
```

```
Update the stablecoin yield strategy to check for better opportunities.
```

```
Exit the stablecoin yield strategy and return funds to my main wallet.
```

### CLI alternative

For scripting or automation:

```bash
poetry run python -m wayfinder_paths.run_strategy STRATEGY_NAME --action status --config config.json
poetry run python -m wayfinder_paths.run_strategy STRATEGY_NAME --action deposit --main-token-amount 100 --gas-token-amount 0.01 --config config.json
poetry run python -m wayfinder_paths.run_strategy STRATEGY_NAME --action update --config config.json
poetry run python -m wayfinder_paths.run_strategy STRATEGY_NAME --action exit --config config.json
```

Run continuously (every 5 minutes):

```bash
poetry run python -m wayfinder_paths.run_strategy STRATEGY_NAME --action run --interval 300 --config config.json
```

## Next steps

* [Configuration](/wayfinder/sdk-setup/configuration.md) — API key, RPC URLs, wallets
* [Architecture](/wayfinder/sdk-concepts/architecture.md) — how the SDK layers work
* [Protocols](/wayfinder/protocols-and-adapters/protocols.md) — per-protocol guides