Downloading Rover, cloning the repo, and setting up Claude

2. Project setup

Overview

Let's get to know our project, from API to assistant!

In this lesson, we will:

Learn about the domain we'll be working with
Set up the Rover CLI and starter files
Download and chat with Claude

Introducing Airlock

Want to book a trip to new, exciting, sometimes-fictional places in the vast universe? Enter Airlock!

The Airlock app homepage with a list of places to book.

With Airlock, you can find listings that meet your dates of choice and the number of beds you'll need. Learn what each place is all about and what amenities it offers, and if you're interested, you can book your stay in one click (provided you have enough space credits in your wallet of course)!

We won't be building Airlock in this course. Instead, we're going to take functionality that already exists in this API (such as queries for listings, their amenities, etc.) and capture it in various tools that we'll provide to our assistant.

First, we'll start small. Airlock is all about listings, so that's where we begin. Expand the collapsible below to see the schema we'll be starting with, which is live to query here.

type Amenity {
  id: ID!
  category: AmenityCategory!
  name: String!
}

enum AmenityCategory {
  ACCOMMODATION_DETAILS
  SPACE_SURVIVAL
  OUTDOORS
}

input CreateListingInput {
  """The listing's title"""
  title: String!
  """The listing's description"""
  description: String!
  """The thumbnail image for the listing"""
  photoThumbnail: String!
  """The number of beds available"""
  numOfBeds: Int!
  """The cost per night"""
  costPerNight: Float!
  """The location type of the listing"""
  locationType: LocationType!
  """The Listing's amenities """
  amenities: [ID!]!
}

type CreateListingResponse implements MutationResponse {
  """Similar to HTTP status code, represents the status of the mutation"""
  code: Int!
  """Indicates whether the mutation was successful"""
  success: Boolean!
  """Human-readable message for the UI"""
  message: String!
  """The newly created listing"""
  listing: Listing
}

"""Coordinates in the galaxy"""
type GalacticCoordinates {
  latitude: Float!
  longitude: Float!
  nickname: String
}

type Host {
  id: ID!
}

type Listing {
  id: ID!
  """The listing's title"""
  title: String!
  """The listing's description"""
  description: String!
  """The thumbnail image for the listing"""
  photoThumbnail: String!
  """Photo edited for homepage"""
  photoInHexagonShape: String @deprecated(reason: "Unused field.")
  """The number of beds available"""
  numOfBeds: Int!
  """The cost per night"""
  costPerNight: Float!
  """The location type of the listing"""
  locationType: LocationType!
  """Owner of the listing"""
  host: Host!
  """The amenities available for this listing"""
  amenities: [Amenity]!
  """Where this listing is located in the galaxy"""
  coordinates: GalacticCoordinates
}

enum LocationType {
  SPACESHIP
  HOUSE
  CAMPSITE
  APARTMENT
  ROOM
}

type Mutation {
  """Creates a new listing for the currently authenticated host"""
  createListing(listing: CreateListingInput!): CreateListingResponse!
  """Updates an existing listing"""
  updateListing(listingId: ID!, listing: UpdateListingInput!): UpdateListingResponse!
}

interface MutationResponse {
  """Similar to HTTP status code, represents the status of the mutation"""
  code: Int!
  """Indicates whether the mutation was successful"""
  success: Boolean!
  """Human-readable message for the UI"""
  message: String!
}

"""Listing Graph"""
type Query {
  """A curated array of listings to feature on the homepage"""
  featuredListings: [Listing!]!
  """Search results for listings that fit the criteria provided"""
  searchListings(criteria: SearchListingsInput): [Listing!]!
  """Return the listings that belong to the currently logged-in host"""
  hostListings: [Listing!]!
  """Returns the details about this listing"""
  listing(id: ID!): Listing
  """Returns all possible amenities for a listing"""
  listingAmenities: [Amenity!]!
}

input SearchListingsInput {
  checkInDate: String!
  checkOutDate: String!
  numOfBeds: Int
  page: Int
  limit: Int
  sortBy: SortByCriteria
}

enum SortByCriteria {
  COST_ASC
  COST_DESC
  RATING_DESC
}

"""
Updates the properties included. If none are given, don't update anything
"""
input UpdateListingInput {
  """The listing's title"""
  title: String
  """The listing's description"""
  description: String
  """The thumbnail image for the listing"""
  photoThumbnail: String
  """The number of beds available"""
  numOfBeds: Int
  """The cost per night"""
  costPerNight: Float
  """The location type of the listing"""
  locationType: LocationType
  """The Listing's amenities """
  amenities: [ID]
}

type UpdateListingResponse implements MutationResponse {
  """Similar to HTTP status code, represents the status of the mutation"""
  code: Int!
  """Indicates whether the mutation was successful"""
  success: Boolean!
  """Human-readable message for the UI"""
  message: String!
  """The newly created listing"""
  listing: Listing
}

Setting up our tools

Because the listings server is hosted elsewhere, we won't need to download any API-related code. But there are a few other components we'll need to get in place before proceeding.

First off, we'll need Rover, Apollo's official command-line interface tool for interacting with graphs. We'll use Rover to run and test our MCP server.
Next, we'll define the details about our graph, such as where it's running and how to retrieve its schema.
Finally, we'll set up our AI assistant, Claude, by Anthropic. Like many other contemporary LLMs, it excels in text generation, answering questions, and assisting with a variety of tasks.

Let's get to it!

Installing Rover

In upcoming lessons, we'll use Rover to run both our local router and our MCP server. You will need at least v0.32.0 to follow along with the course.

Task!

I've installed and authenticated the Rover CLI.

Cloning the repository

Next, let's get our project cloned. Navigate to a new empty directory somewhere on your computer, and run the following command.

git clone https://github.com/apollographql-education/odyssey-apollo-mcp.git

Taking a look inside of our repo, we'll see that it contains an empty operations folder, along with a single file called supergraph.yaml.

📂 odyssey-apollo-mcp
  ┣  📂 operations
  ┗ 📄 supergraph.yaml

We'll add files to the operations folder as we work through the course.

Next, let's get our AI assistant running.

Setting up the AI assistant Claude

Head to Claude's Download page and select the option for your operating system. When the download completes, launch the application. You'll need to sign up for an account with Anthropic, but we won't do anything in this course that requires a paid subscription.

Once you've completed the onboarding process, you should see a chat interface where you can write your first messages to Claude.

The Claude Desktop app opened and waiting for a prompt

Chatting with Claude

Let's take it for a spin. Checking our listings schema (in the collapsible at the top of this lesson), we'll see the featuredListings entrypoint on the Query type.

type Query {
  "A curated array of listings to feature on the homepage"
  featuredListings: [Listing!]!
  # ... other Query fields
}

But if we ask about featured listings, is Claude going to be able to tell us anything?

We can start our chat with the question:

A prompt for Claude

What are the featured listings today?

Claude's response to our question, indicating lack of knowledge

Claude, as we might have predicted, won't be able to give us any information about featured listings. It has no idea where to begin! We haven't provided any context about what listings, or where it might even find that information.

We could try again, with a more explicit question that includes the API URL:

A more specific prompt for Claude

Can you tell me about the featured listings at https://rt-airlock-subgraphs-listings.herokuapp.com/?

We'll see in response that Claude is not able to make HTTP requests to external services or APIs. And even if it were able to retrieve data directly from the API and tell us about it, our users would always have to provide the endpoint themselves for the assistant to inspect. Not a very good chat experience!

Claude's response to our question, showing that it cannot access external websites

This is a great illustration of why we need tools: special actions that we can equip our assistant with, so it can ultimately get the information that our users are after.

Task!

I've installed Claude.

Key takeaways

Our setup includes the Rover CLI, a configuration file, and the AI assistant Claude.

Up next

Our AI assistant is currently powerless to answer our burning questions about Airlock's listings. In the next lesson, let's get our API running locally.

Share your questions and comments about this lesson

This course is currently in

beta

. Your feedback helps us improve! If you're stuck or confused, let us know and we'll help you out. All comments are public and must follow the Apollo Code of Conduct. Note that comments that have been resolved or addressed may be removed.

You'll need a GitHub account to post below. Don't have one? Post in our Odyssey forum instead.