@@ -88,7 +88,8 @@ Failures exit non-zero with a short message on stderr and no traceback.
 
 `osw[mcp]` ships an [MCP](https://modelcontextprotocol.io) server that exposes a
 live OpenSemanticLab instance to MCP clients such as Claude Code. It wraps
-`OswExpress` and provides tools to search (semantic / SPARQL / page titles),
+`OswExpress` and provides tools to search (semantic / SPARQL / page titles /
+page content),
 introspect category schemas, read entities and every page slot, create/update
 and delete entities, and read and write file pages as text. The transport is
 stdio; SSE and HTTP are not supported.
 
@@ -1,4 +1,4 @@
-"""Search and query operations: semantic (SMW ask), titles, instances, SPARQL."""
+"""Search operations: semantic (SMW ask), titles, content, instances, SPARQL."""
 
 from __future__ import annotations
 
@@ -63,6 +63,7 @@ def search_titles(ctx: Context, text: str, limit: Optional[int] = None) -> dict:
     ``prefixsearch`` API. OSW pages are titled by OSW-ID, for example
     ``Item:OSW7ec...``, so an entity's name is not part of its title and
     cannot be found here. Use ``osw search ask`` to search by name.
+    Use ``osw search content`` to search the text of pages.
 
     Useful for the titles that are readable: categories, properties,
     templates and other schema pages.
@@ -77,6 +78,31 @@ def search_titles(ctx: Context, text: str, limit: Optional[int] = None) -> dict:
     return {"titles": capped, "count": total, "truncated": truncated}
 
 
+@operation(
+    group="search",
+    cli_name="content",
+    read_only_hint=True,
+    idempotent_hint=True,
+)
+def search_content(ctx: Context, text: str, limit: Optional[int] = None) -> dict:
+    """Search the text content of pages for ``text``.
+
+    Uses the MediaWiki ``search`` API, which reads page wikitext. On an OSW
+    instance an entity's data lives in JSON slots, so a value stored as
+    structured data may not be reachable here; ``osw search ask`` queries
+    that data directly and is the better tool for it.
+
+    Returns page titles, not the matching passages. ``limit`` defaults to
+    ``OSW_MAX_RESULTS`` (100 when that is unset). Returns
+    ``{titles, count, truncated}``, where ``titles`` are full page names
+    and ``count`` is how many the wiki returned.
+    """
+    lim = ctx.limit(limit)
+    titles = ctx.osw.site.content_search(WtSite.SearchParam(query=text, limit=lim))
+    capped, total, truncated = cap_list(titles, lim)
+    return {"titles": capped, "count": total, "truncated": truncated}
+
+
 @operation(
     group="search",
     cli_name="instances",
 
@@ -216,6 +216,70 @@ def prefix_search_(single_text) -> Union[List[str], dict]:
     #  return page_list  # original return
 
 
+def content_search(
+    site: mwclient.client.Site, text: Union[str, List[str], SearchParam]
+) -> Union[List[str], List[dict]]:
+    """Searches the content (wikitext) of pages. Equivalent to the following
+    mediawiki API call api.php?action=query&list=search&srsearch=Star Wars.
+
+    See https://www.mediawiki.org/wiki/API:Search for details.
+
+    Parameters
+    ----------
+    site :
+        Site object from mwclient lib
+    text :
+        Query text or instance of SearchParam
+
+    Returns
+    -------
+    result:
+        With ``return_json=False`` (default): a flat list of page titles. With
+        ``return_json=True``: a list of raw MediaWiki ``search`` API response
+        dicts, one per query (always a list, even for a single query).
+    """
+    if not isinstance(text, SearchParam):
+        query = SearchParam(query=text)
+    else:
+        query = text
+
+    def content_search_(single_text) -> Union[List[str], dict]:
+        page_list = list()
+        result = site.api(
+            "query",
+            list="search",
+            srsearch=single_text,
+            srlimit=query.limit,
+            format="json",
+        )
+        if query.debug and len(result["query"]["search"]) == 0:
+            print("No results")
+        if query.return_json:
+            return result
+
+        for page in result["query"]["search"]:
+            title = page["title"]
+            if query.debug:
+                print(title)
+            page_list.append(title)
+        return page_list
+
+    if query.parallel:
+        query_results = parallelize(
+            func=content_search_, iterable=query.query, flush_at_end=query.debug
+        )
+    else:
+        query_results = [content_search_(single_text=sq) for sq in query.query]
+
+    if query.return_json:
+        # Each entry of query_results is the raw API response dict for one query.
+        # Do not flatten dicts; always return the list of responses (one per query),
+        # even when only a single query was passed.
+        return query_results
+
+    return [item for sublist in query_results for item in sublist]
+
+
 def semantic_search(
     site: mwclient.client.Site, query: Union[str, List[str], SearchParam]
 ) -> Union[List[str], List[dict]]:
 
@@ -532,6 +532,21 @@ def prefix_search(self, text: Union[str, SearchParam]):
         """
         return wt.prefix_search(self._site, text)
 
+    @try_and_renew_token
+    def content_search(self, text: Union[str, SearchParam]):
+        """Send a content (full-text) search request to the site.
+
+        Parameters
+        ----------
+        text
+            The search text or a SearchParam object
+
+        Returns
+        -------
+            A list of page titles
+        """
+        return wt.content_search(self._site, text)
+
     @try_and_renew_token
     def semantic_search(self, query: Union[str, SearchParam]):
         """Send a swm ask query to the site.
 
@@ -44,6 +44,19 @@ def test_search_titles_calls_prefix_search():
     osw.site.prefix_search.assert_called_once()
 
 
+def test_search_content_calls_content_search():
+    osw = MagicMock()
+    osw.site.content_search.return_value = ["Item:OSW1"]
+    ctx = Context(_settings(), Policy(), osw=osw)
+
+    result = search.search_content(ctx, text="sensor")
+
+    assert result["titles"] == ["Item:OSW1"]
+    assert result["count"] == 1
+    assert result["truncated"] is False
+    osw.site.content_search.assert_called_once()
+
+
 def test_list_instances_of_category_calls_query_instances():
     osw = MagicMock()
     osw.query_instances.return_value = ["Item:OSW1", "Item:OSW2"]
 
@@ -128,3 +128,42 @@ def test_prefix_search_returns_flat_list_of_titles():
 
     # return_json=False (the default) still yields a flat list of page titles
     assert out == ["Star Wars", "Star Trek"]
+
+
+def _search_result(*titles):
+    """Build a minimal MediaWiki ``search`` API result dict."""
+    return {
+        "batchcomplete": "",
+        "query": {
+            "search": [
+                {"ns": 0, "title": title, "pageid": idx}
+                for idx, title in enumerate(titles, start=1)
+            ]
+        },
+    }
+
+
+def test_content_search_returns_flat_list_of_titles():
+    result = _search_result("Star Wars", "Star Trek")
+    site = MagicMock()
+    site.api.return_value = result
+
+    out = wt.content_search(site, "Star")
+
+    # return_json=False (the default) still yields a flat list of page titles
+    assert out == ["Star Wars", "Star Trek"]
+
+
+def test_content_search_calls_the_search_api():
+    site = MagicMock()
+    site.api.return_value = _search_result("Star Wars", "Star Trek")
+
+    wt.content_search(site, wt.SearchParam(query="Star", limit=7))
+
+    # Pin the API contract: the content search must use list=search with its
+    # sr* parameters, not list=prefixsearch
+    args, kwargs = site.api.call_args
+    assert args == ("query",)
+    assert kwargs["list"] == "search"
+    assert kwargs["srsearch"] == "Star"
+    assert kwargs["srlimit"] == 7