First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the FastAPI documentation, with the integrated search.
• I already searched in Google "How to X in FastAPI" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to FastAPI but to Pydantic.
• I already checked if it is not related to FastAPI but to Swagger UI.
• I already checked if it is not related to FastAPI but to ReDoc.

Commit to Help

• I commit to help with one of those options 👆

Example Code

"""
  The NoSQL tutorial (docs_src/nosql_databases/tutorial001_scylla.py) demonstrates
  FastAPI integration with ScyllaDB:
  """

  from contextlib import asynccontextmanager
  from typing import List, Union
  from uuid import UUID, uuid4
  from cassandra.cluster import Cluster
  from fastapi import Depends, FastAPI, HTTPException
  from pydantic import BaseModel, Field


  class TaskBase(BaseModel):
      title: str
      description: Union[str, None] = None
      status: str = "pending"


  class TaskCreate(TaskBase):
      pass


  class Task(TaskBase):
      id: UUID = Field(default_factory=uuid4)


  class ScyllaDBConnection:
      def __init__(self, hosts=["scylladb"], port=9042):
          self.cluster = Cluster(hosts, port=port)
          self.session = None
          self.keyspace = "task_manager"

      def connect(self):
          self.session = self.cluster.connect()
          self.create_keyspace()
          self.session.set_keyspace(self.keyspace)
          self.create_table()

      def create_keyspace(self):
          self.session.execute(
              f"""
              CREATE KEYSPACE IF NOT EXISTS {self.keyspace}
              WITH replication = {{'class': 'SimpleStrategy', 'replication_factor': 1}}
              """
          )

      def create_table(self):
          self.session.execute(
              """
              CREATE TABLE IF NOT EXISTS tasks (
                  id uuid PRIMARY KEY,
                  title text,
                  description text,
                  status text,
                  created_at timestamp,
                  updated_at timestamp
              )
              """
          )

      def close(self):
          if self.session:
              self.session.shutdown()
          if self.cluster:
              self.cluster.shutdown()


  db = ScyllaDBConnection()


  @asynccontextmanager
  async def lifespan(app: FastAPI):
      db.connect()
      yield
      db.close()


  app = FastAPI(lifespan=lifespan)


  def get_db():
      return db.session


  @app.post("/tasks/", response_model=Task)
  def create_task(task: TaskCreate, session=Depends(get_db)):
      task_id = uuid4()
      query = """
          INSERT INTO tasks (id, title, description, status, created_at, updated_at)
          VALUES (%s, %s, %s, %s, toTimestamp(now()), toTimestamp(now()))
      """
      session.execute(query, (task_id, task.title, task.description, task.status))
      return Task(id=task_id, **task.model_dump())


  @app.get("/tasks/", response_model=List[Task])
  def read_tasks(session=Depends(get_db)):
      query = "SELECT id, title, description, status FROM tasks"
      rows = session.execute(query)
      return [
          Task(id=row.id, title=row.title, description=row.description, status=row.status)
          for row in rows
      ]

Description

FastAPI documentation currently doesn't mention NoSQL database integration, even though FastAPI works well with NoSQL databases like ScyllaDB, Cassandra, MongoDB, Redis, etc.

The problem:

• FastAPI has excellent SQL database tutorials (SQLModel, SQLAlchemy)
• NoSQL databases are not mentioned anywhere in the official documentation
• Developers assume FastAPI only works with SQL databases or need to search elsewhere

What's already happening in the community:

• Community articles demonstrate FastAPI + Cassandra integration:
  https://dev.to/csar_fabinchvezlinar/building-a-task-management-api-with-apache-cassandra-and-fastapi-3ho0
• DataStax Astra DB has FastAPI integration docs:
  https://awesome-astra.github.io/docs/pages/develop/frameworks/fastapi/
• Developers are successfully using FastAPI with NoSQL in production

What could happen instead:

• FastAPI docs should include a NoSQL databases tutorial (similar to the SQL tutorial)
• Demonstrate integration with ScyllaDB/Cassandra as an example
• Include tests validating the tutorial code works with real databases

This would help FastAPI users discover NoSQL options and prove FastAPI's flexibility beyond SQL databases.

Operating System

macOS

Operating System Details

No response

FastAPI Version

0.121.1

Pydantic Version

2.12.4

Python Version

3.14.0

Additional Context

I have prepared a PR with a complete NoSQL tutorial for ScyllaDB/Cassandra, including documentation and code examples.

The tutorial code has been manually tested locally against real ScyllaDB and Cassandra containers using Docker Compose to verify that it works correctly.

Current testing approach:

• Automated tests use mocked database operations for fast CI execution without Docker dependencies
• Validates FastAPI structure, routing, and Pydantic models
• Does NOT validate actual database operations in CI

This differs from the SQL tutorial which uses real SQLite (in-memory database).

Suggested future enhancement:

• Add integration tests with real ScyllaDB/Cassandra containers using testcontainers-python
• Would prove the tutorial code actually works end-to-end in CI
• Would validate ScyllaDB's drop-in compatibility with Cassandra
• Could run separately from fast mocked tests (e.g., nightly or on-demand)

Community validation:
The integration pattern has been validated by community articles and production usage:

• https://dev.to/csar_fabinchvezlinar/building-a-task-management-api-with-apache-cassandra-and-fastapi-3ho0
• https://awesome-astra.github.io/docs/pages/develop/frameworks/fastapi/

I'm happy to implement integration tests in the initial PR or as a follow-up, depending on maintainer preference.