From Portable Spell-Checkers to LLMs: How AI Finally Lets Me Write

Rebuilding the Heart of My Classic: 4.2L V8 Engine Restoration

From Chat to Star Wars: A Simple POC Integrating GraphQL with LangGraph

Welcome to Roving Code: Two Distinct Drives

I find the best way to learn a new framework is to hack together a proof of concept. That’s exactly what I did when I wanted to see how **LangGraph** could play with **GraphQL** and since everything is more fun when it's Star Wars themed... I wired my graph up to the public [SWAPI GraphQL endpoint](https://swapi-graphql.netlify.app/).

## 1. Getting the project bootstrapped

First things first Python 3.12 is required. So make sure you have this installed on your system. I would also recommend you use a virtual environment.

```bash
mkdir langgraph-demo
cd langgraph-demo
pip install -U "langgraph-cli[inmem]"
langgraph new . --template new-langgraph-project-python
pip install -e .
```

`langgraph-cli[inmem]` installs the in-memory database for LangGraph. `langgraph new . --template new-langgraph-project-python` creates a new LangGraph project. `pip install -e .` installs the project in editable mode.

LangGraph comes with an `.env.example` file. Copy it over and fill in your secrets:

```bash
cp .env.example .env
```

Inside `.env`, I added:

- `LANGSMITH_API_KEY` for LangSmith observability  
- `OPENROUTER_API_KEY` for access to multiple models   
- `OPENROUTER_BASE_URL=https://openrouter.ai/api/v1`  

With that ready, spin up the dev server:

```bash
langgraph dev
```

![FULLWIDTH Screenshot from langgraph showing the initial graph from the initial setup | Langchart up and running](/images/blog/langgraph_graphql_poc/Screenshot-2025-09-16-175343.png)


## 2. A minimal chat graph with OpenRouter

Now that we have a LangGraph project up and running, we need to add chat. I started with a basic chat flow. Integrating OpenRouter so that we can easily switch models without managing multiple API keys. I prefer using OpenRouter over a specific model provider as it allows me to change models with ease. Here’s my initial `graph.py`:

```python
from typing import Annotated
from langchain_openai import ChatOpenAI
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from os import getenv
from dotenv import load_dotenv

load_dotenv()

class State(TypedDict):
    messages: Annotated[list, add_messages]

graph_builder = StateGraph(State)

llm = ChatOpenAI(
  api_key=getenv("OPENROUTER_API_KEY"),
  base_url=getenv("OPENROUTER_BASE_URL"),
  model="openai/gpt-5-mini"
)

def chatbot(state: State):
    return {"messages": [llm.invoke(state["messages"])]}

graph_builder.add_node("chatbot", chatbot)
graph_builder.add_edge(START, "chatbot")
graph_builder.add_edge("chatbot", END)

graph = graph_builder.compile()
```

Submitting a test message in the UI:

```json
{"messages": [{"role": "user", "content": "What is the airspeed velocity of an unladen swallow?"}]}
```

![FULLWIDTH image showing the initial chat test message being routed to openrouter | LangGraph message test](/images/blog/langgraph_graphql_poc/Screenshot-2025-09-17-100047.png)

At this stage, LangGraph is just a relay between user input and the LLM. Now, let’s add in a GraphQL tool call. Bonus points if you spotted the Monty Python reference!


## 3. Adding GraphQL Into the Mix

I wanted the graph to be able to query a GraphQL API. For that, I installed some extras:

```bash
pip install httpx gql
pip install --upgrade langchain-community
```

`httpx` is a HTTP client for Python, and `gql` is a GraphQL client for Python. `langchain-community` is a collection of community-contributed tools and integrations for LangChain.

I grabbed the Star Wars schema (`starwars_schema.graphql`) and updated my graph code to add in a new tool call to the graphQL API.
The schema file was downloaded from the Star Wars GraphQL github repo available [here](https://github.com/graphql/swapi-graphql/blob/master/schema.graphql).

Here’s the **enhanced version**:

```python
from typing import Annotated
from langchain_openai import ChatOpenAI
from typing_extensions import TypedDict
from langchain_core.messages import ToolMessage, SystemMessage
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from langgraph.prebuilt import ToolNode
from langchain_community.agent_toolkits.load_tools import load_tools
from os import getenv
from dotenv import load_dotenv

load_dotenv()

def load_graphql_schema():
    schema_path = "../starwars_schema.graphql"
    with open(schema_path, 'r') as f:
        return f.read()

graphql_schema = load_graphql_schema()

tools = load_tools(
    ["graphql"],
    graphql_endpoint="https://swapi-graphql.netlify.app/graphql",
    fetch_schema_from_transport=False,
)

class State(TypedDict):
    messages: Annotated[list, add_messages]

graph_builder = StateGraph(State)

llm = ChatOpenAI(
  api_key=getenv("OPENROUTER_API_KEY"),
  base_url=getenv("OPENROUTER_BASE_URL"),
  model="openai/gpt-5-mini"
)

llm_with_tools = llm.bind_tools(tools)

def chatbot(state: State):
    system_message = SystemMessage(content=f"""You are a Star Wars nerd. Use the GraphQL tool to query the endpoint and answer questions.

Available GraphQL schema:
{graphql_schema}
""")
    messages = state["messages"]
    if not messages or not isinstance(messages[0], SystemMessage):
        messages = [system_message] + messages
    
    return {"messages": [llm_with_tools.invoke(messages)]}

def should_continue(state: State):
    messages = state['messages']
    last_message = messages[-1]
    if last_message.tool_calls:
        return "tools"
    return END

tool_node = ToolNode(tools)

graph_builder.add_node("chatbot", chatbot)
graph_builder.add_node("tools", tool_node)
graph_builder.add_edge(START, "chatbot")
graph_builder.add_conditional_edges("chatbot", should_continue, {"tools": "tools", END: END})
graph_builder.add_edge("tools", "chatbot")

graph = graph_builder.compile()
```

Now when I ask:

```json
{"messages": [{"role": "user", "content": "Tell me about Anakin Skywalker"}]}
```

The LLM routes the request to the GraphQL tool, constructs a proper query against the SWAPI endpoint, and pulls back structured data.

![FULLWIDTH Screenshot of LangGraph showing the event chain from user request to response via the GraphQL tool call | GraphQL query response about Anakin Skywalker](/images/blog/langgraph_graphql_poc/Screenshot-2025-09-17-160432.png)


## 4. How this works

- **LangGraph** provides the state machine to orchestrate steps.  
- **OpenRouter** serves the model API for reasoning.  
- **LangChain community tools** give us a drop-in GraphQL executor.  
- **SystemMessage with schema context** ensures the model generates valid GraphQL queries.  
- The **conditional edge (`should_continue`)** checks if the model requested a tool call, routing execution to the GraphQL node before looping back.  

This is enough to stitch a conversational agent with real data access in less than a hundred lines of code.


## 5. Next steps

I see a few clear directions to take this further:

- Swap the static schema file for **live introspection** of GraphQL APIs  
- Add **retry logic** if the model generates invalid queries  
- Incorporate **more complex data sources** (REST + GraphQL) for more practical use cases
- Explore **LangSmith traces** to debug prompt/tool handoffs  


## Final thoughts

This little proof of concept shows how usable LangGraph actually is. I went from a barebones chatbot to a Star Wars trivia machine powered by live GraphQL queries in less than a hundred lines of code.

If you’re tinkering with LangGraph, I highly recommend adding a data source you care about.

May the graphs be with you...