feat: Adds people search tool (#89)

Author: steve-calvert-glean

README.md

@@ -5,12 +5,13 @@
 [![npm version](https://badge.fury.io/js/@gleanwork%2Fmcp-server.svg)](https://badge.fury.io/js/@gleanwork%2Fmcp-server)
 [![License](https://img.shields.io/npm/l/@gleanwork%2Fmcp-server.svg)](https://github.com/gleanwork/mcp-server/blob/main/LICENSE)
 
-A Model Context Protocol (MCP) server implementation for Glean's search and chat capabilities. This server provides a standardized interface for AI models to interact with Glean's content search and conversational AI features.
+The Glean MCP Server is a [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) server that provides seamless integration with Glean's enterprise knowledge.
 
 ## Features
 
-- **Search Integration**: Access Glean's powerful content search capabilities
-- **Chat Interface**: Interact with Glean's AI assistant
+- **Company Search**: Access Glean's powerful content search capabilities
+- **People Profile Search**: Access Glean's people directory
+- **Chat**: Interact with Glean's AI assistant
 - **MCP Compliant**: Implements the Model Context Protocol specification
 
 ## Tools
@@ -19,13 +20,13 @@ A Model Context Protocol (MCP) server implementation for Glean's search and chat
 
   Search Glean's content index using the Glean Search API. This tool allows you to query Glean's content index with various filtering and configuration options.
 
-  For complete parameter details, see [Search API Documentation](https://developers.glean.com/client/operation/search/)
-
 - ### chat
 
   Interact with Glean's AI assistant using the Glean Chat API. This tool allows you to have conversational interactions with Glean's AI, including support for message history, citations, and various configuration options.
 
-  For complete parameter details, see [Chat API Documentation](https://developers.glean.com/client/operation/chat/)
+- ### people_profile_search
+
+  Search Glean's People directory to find employee information.
 
 ## Configuration
 

src/configure.ts

@@ -137,12 +137,9 @@ export async function configure(client: string, options: ConfigureOptions) {
     }
 
     // For non-token auth flow (requires GLEAN_OAUTH_ENABLED)
- 	const { instanceOrUrl } = loadCredentials(options);
-    	if (!instanceOrUrl) {
-      		throw new Error('Instance or URL is required for OAuth configuration');
-
-
-
+    const { instanceOrUrl } = loadCredentials(options);
+    if (!instanceOrUrl) {
+      throw new Error('Instance or URL is required for OAuth configuration');
     }
 
     // Set environment variables for OAuth flow

src/server.ts

@@ -20,6 +20,7 @@ import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import * as search from './tools/search.js';
 import * as chat from './tools/chat.js';
+import * as peopleProfileSearch from './tools/people_profile_search.js';
 import {
   isGleanError,
   GleanError,
@@ -34,6 +35,7 @@ import { VERSION } from './common/version.js';
 
 export const TOOL_NAMES = {
   companySearch: 'company_search',
+  peopleProfileSearch: 'people_profile_search',
   chat: 'chat',
 };
 
@@ -50,18 +52,15 @@ const server = new Server(
 );
 
 /**
- * Handles tool discovery requests by providing a list of available tools.
- * Each tool includes its name, description, and input schema in JSON Schema format.
- *
- * @returns {Promise<{tools: Array<{name: string, description: string, inputSchema: object}>}>}
+ * Returns the list of available tools with descriptions & JSON Schemas.
  */
-server.setRequestHandler(ListToolsRequestSchema, async () => {
+export async function listToolsHandler() {
   return {
     tools: [
       {
         name: TOOL_NAMES.companySearch,
         description: `Find relevant company documents and data
-        
+
         Example request:
 
         {
@@ -87,23 +86,36 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         `,
         inputSchema: zodToJsonSchema(chat.ToolChatSchema),
       },
+      {
+        name: TOOL_NAMES.peopleProfileSearch,
+        description: `Search for people profiles in the company
+
+        Example request:
+
+        {
+            "query": "Find people named John Doe",
+            "filters": {
+                "department": "Engineering",
+                "city": "San Francisco"
+            },
+            "pageSize": 10
+        }
+
+        `,
+        inputSchema: zodToJsonSchema(
+          peopleProfileSearch.ToolPeopleProfileSearchSchema,
+        ),
+      },
     ],
   };
-});
+}
 
 /**
- * Handles tool execution requests by validating input and dispatching to the appropriate tool.
- * Supports the following tools:
- * - search: Executes a search query against Glean's index
- * - chat: Initiates or continues a conversation with Glean's AI
- *
- * @param {object} request - The tool execution request
- * @param {string} request.params.name - The name of the tool to execute
- * @param {object} request.params.arguments - The arguments to pass to the tool
- * @returns {Promise<{content: Array<{type: string, text: string}>}>}
- * @throws {Error} If arguments are missing, tool is unknown, or validation fails
+ * Executes a tool based on the MCP callTool request.
  */
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
+export async function callToolHandler(
+  request: z.infer<typeof CallToolRequestSchema>,
+) {
   try {
     if (!request.params.arguments) {
       throw new Error('Arguments are required');
@@ -123,11 +135,24 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case TOOL_NAMES.chat: {
         const args = chat.ToolChatSchema.parse(request.params.arguments);
-        const response = await chat.chat(args);
-        const formattedResponse = chat.formatResponse(response);
+        const result = await chat.chat(args);
+        const formattedResults = chat.formatResponse(result);
 
         return {
-          content: [{ type: 'text', text: formattedResponse }],
+          content: [{ type: 'text', text: formattedResults }],
+          isError: false,
+        };
+      }
+
+      case TOOL_NAMES.peopleProfileSearch: {
+        const args = peopleProfileSearch.ToolPeopleProfileSearchSchema.parse(
+          request.params.arguments,
+        );
+        const result = await peopleProfileSearch.peopleProfileSearch(args);
+        const formattedResults = peopleProfileSearch.formatResponse(result);
+
+        return {
+          content: [{ type: 'text', text: formattedResults }],
           isError: false,
         };
       }
@@ -173,7 +198,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       isError: true,
     };
   }
-});
+}
+
+server.setRequestHandler(ListToolsRequestSchema, listToolsHandler);
+server.setRequestHandler(CallToolRequestSchema, callToolHandler);
 
 /**
  * Formats a GleanError into a human-readable error message.

src/test/mocks/handlers.ts

@@ -122,4 +122,67 @@ export const handlers = [
       });
     },
   ),
+
+  // Handler for people profile search (listentities)
+  http.post(
+    'https://:instance-be.glean.com/rest/api/v1/listentities',
+    async ({ request }) => {
+      const authHeader = request.headers.get('Authorization');
+
+      if (!authHeader || authHeader === 'Bearer invalid_token') {
+        return new HttpResponse('Invalid Secret\nNot allowed', {
+          status: 401,
+          statusText: 'Unauthorized',
+          headers: {
+            'Content-Type': 'text/plain; charset=utf-8',
+          },
+        });
+      }
+
+      if (authHeader === 'Bearer expired_token') {
+        return new HttpResponse('Token has expired\nNot allowed', {
+          status: 401,
+          statusText: 'Unauthorized',
+          headers: {
+            'Content-Type': 'text/plain; charset=utf-8',
+          },
+        });
+      }
+
+      if (authHeader === 'Bearer network_error') {
+        const error = new Error('Network error');
+        error.name = 'FetchError';
+        throw error;
+      }
+
+      if (authHeader === 'Bearer server_error') {
+        return new HttpResponse('Something went wrong', {
+          status: 500,
+          statusText: 'Internal Server Error',
+          headers: {
+            'Content-Type': 'text/plain; charset=utf-8',
+          },
+        });
+      }
+
+      const responseData = {
+        results: [
+          {
+            name: 'Jane Doe',
+            obfuscatedId: 'abc123',
+            metadata: {
+              title: 'Software Engineer',
+              department: 'Engineering',
+              location: 'San Francisco',
+              email: 'jane.doe@example.com',
+            },
+          },
+        ],
+        totalCount: 1,
+        hasMoreResults: false,
+      };
+
+      return HttpResponse.json(responseData);
+    },
+  ),
 ];