> ## Documentation Index > Fetch the complete documentation index at: https://nikita-shkoda.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Quickstart > Fastest path to a working search: install, configure, define a model, and run your first query. Prerequisites ```ruby theme={null} # Gemfile gem "search-engine-for-typesense" ``` Then run Bundler to install dependencies in your host app. ```bash theme={null} rails g search_engine:install ``` This will create a new initializer in `config/initializers/search_engine.rb`. See Generators & Console helpers for more details. ```ruby theme={null} # config/initializers/search_engine.rb SearchEngine.configure do |c| c.host = ENV.fetch("TYPESENSE_HOST", "localhost") c.port = 8108 c.protocol = "http" c.api_key = ENV.fetch("TYPESENSE_API_KEY") c.default_query_by = "name, description" end ``` * host/port/protocol: where your Typesense node is reachable; defaults are safe for localhost. * api\_key: read from ENV.fetch("TYPESENSE\_API\_KEY") so secrets never live in code. * default\_query\_by: default fields used when you do not pass query\_by explicitly. See Configuration for all options and ENV mapping. ```ruby theme={null} class SearchEngine::Book < SearchEngine::Base collection "books" attribute :id, :integer attribute :title, :string end SearchEngine::Book.where(title: "ruby").select(:id, :title).limit(5).to_a ``` Ensure your Typesense books collection exists with at least id (int64) and title (string). You can also use a Generator to create a new model: ```bash theme={null} rails g search_engine:model Book --collection books --attrs id:integer title:string ``` This will create a new model in `app/models/search_engine/book.rb`. You can let the model orchestrate schema and indexing: ```ruby theme={null} # Create collection + apply schema if needed, reindex, retention cleanup SearchEngine::Book.index_collection # Index a specific partition (collection must exist and be in-sync) SearchEngine::Book.index_collection(partition: publisher_id) ``` See Indexer for details. For one-off reindexing by key, call the model-level helper: ```ruby theme={null} SearchEngine::Book.rebuild_partition!(partition: publisher_id) SearchEngine::Book.rebuild_partition!(partition: publisher_id, into: "optional_physical_collection") ``` See Indexer → Partitioning for the partitioning DSL. Open rails console and paste the trailing line from the snippet above. It runs against Typesense and returns up to 5 Book records with only id and title hydrated. This uses the Relation → Client stack under the hood. ## Request flow ```mermaid theme={null} sequenceDiagram autonumber participant App participant Relation participant Compiler participant Client participant Typesense App->>Relation: chain where/select/limit Relation->>Compiler: compile params Compiler->>Client: request(url, body, url_opts) Client->>Typesense: POST /collections/.../documents/search Typesense-->>Client: hits JSON Client-->>App: map → Results ``` ## Next steps * Multi‑search: run multiple searches in one network call. * JOINs: join related collections and select nested fields. * Grouping: group results and aggregate with counts. ## Troubleshooting * Missing TYPESENSE\_API\_KEY: set the ENV var before boot; see Configuration → ENV mapping. Tip: the CLI doctor checks this. * Connection refused or timeout: verify host/port/protocol; see the CLI → Doctor. * Unknown field errors: declare attributes on the model or adjust selection; see Field selection → Guardrails. ## Related links * Installation * Configuration * Client * Observability — events, logging subscriber, OpenTelemetry * DX — helpers: dry\_run!, to\_params\_json, to\_curl * Relation — chaining DSL used above