Azure DevOps Wiki MCP Server

Instructions

Implementation Reference

• src/azure-client.ts:64-151 (handler)

  Core handler implementation in AzureDevOpsWikiClient that performs the actual wiki search using Azure DevOps Search API, processes results into WikiSearchResult format.

  async searchWiki(request: WikiSearchRequest): Promise<WikiSearchResult[]> {
    if (!this.wikiApi || !this.connection) {
      throw new Error('Azure DevOps client not initialized');
    }
  
    try {
      const organization = request.organization || this.config.organization;
      const project = request.project || this.config.project;
      
      if (!organization || !project) {
        throw new Error('Organization and project must be provided');
      }
  
      const searchApiUrl = `https://almsearch.dev.azure.com/${organization}/${project}/_apis/search/wikisearchresults?api-version=7.1`;
      
      interface WikiSearchRequestBody {
        searchText: string;
        $skip: number;
        $top: number;
        includeFacets: boolean;
        filters?: {
          Wiki?: string[];
        };
      }
  
      const requestBody: WikiSearchRequestBody = {
        searchText: request.searchText,
        $skip: 0,
        $top: 100, // Default to 100 results
        includeFacets: false
      };
  
      // Add wiki filter if specified
      if (request.wikiId) {
        requestBody.filters = {
          Wiki: [request.wikiId]
        };
      }
  
      const response = await this.connection.rest.client.post(searchApiUrl, JSON.stringify(requestBody), {
        'Content-Type': 'application/json'
      });
      
      if (!response.message || response.message.statusCode !== 200) {
        throw new Error(`Search failed: HTTP ${response.message?.statusCode || 'Unknown'}`);
      }
  
      const responseBody = await response.readBody();
      if (!responseBody) {
        return [];
      }
  
      const data = JSON.parse(responseBody);
      
      if (!data.results || !Array.isArray(data.results)) {
        return [];
      }
  
      interface WikiSearchResultItem {
        fileName?: string;
        path?: string;
        url?: string;
        matches?: {
          content?: { text: string }[];
        };
        project?: {
          name: string;
        };
        wiki?: {
          name: string;
        };
      }
  
      return data.results.map((result: WikiSearchResultItem) => ({
        title: result.fileName || (result.path ? result.path.split('/').pop() || 'Unknown' : 'Unknown'),
        url: result.url || '',
        content: result.matches && result.matches.content 
          ? result.matches.content.map((match) => match.text).join(' ')
          : '',
        project: result.project?.name || project,
        wiki: result.wiki?.name || request.wikiId || 'Unknown',
        pagePath: this.formatPagePath(result.path || '')
      }));
  
    } catch (error) {
      throw new Error(`Failed to search wiki: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

• src/server.ts:220-241 (handler)

  MCP server handler for 'search_wiki' tool: validates input with schema, initializes client with org/project, delegates to client.searchWiki, formats response.

  private async handleSearchWiki(args: any) {
    const request = WikiSearchRequestSchema.parse(args);
    const organization = request.organization || this.config.defaultOrganization;
    const project = request.project || this.config.defaultProject;
    
    if (!organization) {
      throw new Error('Organization is required either as parameter or in server configuration');
    }
    if (!project) {
      throw new Error('Project is required either as parameter or in server configuration');
    }
    
    const client = await this.getClient(organization, project);
    const results = await client.searchWiki(request);
    
    return {
      content: [{
        type: 'text',
        text: JSON.stringify(results, null, 2)
      }]
    };
  }

• src/server.ts:31-55 (registration)

  Registration of 'search_wiki' tool in MCP server, including name, description, and input schema.

    name: 'search_wiki',
    description: 'Search across wiki content using Azure DevOps Search API',
    inputSchema: {
      type: 'object',
      properties: {
        organization: {
          type: 'string',
          description: 'Azure DevOps organization name'
        },
        project: {
          type: 'string',
          description: 'Project name'
        },
        searchText: {
          type: 'string',
          description: 'Search query string'
        },
        wikiId: {
          type: 'string',
          description: 'Optional specific wiki identifier'
        }
      },
      required: ['searchText']
    }
  },

• src/types.ts:1-50 (schema)

  Zod schema for input validation (WikiSearchRequestSchema) and TypeScript interface for output (WikiSearchResult) used in search_wiki.

  import { z } from 'zod';
  
  export const WikiSearchRequestSchema = z.object({
    organization: z.string().min(1).optional(),
    project: z.string().min(1).optional(),
    searchText: z.string().min(1),
    wikiId: z.string().optional(),
  });
  
  export const WikiPageTreeRequestSchema = z.object({
    organization: z.string().min(1).optional(),
    project: z.string().min(1).optional(),
    wikiId: z.string().min(1),
    depth: z.number().int().positive().optional(),
  });
  
  export const WikiGetPageRequestSchema = z.object({
    organization: z.string().min(1).optional(),
    project: z.string().min(1).optional(),
    wikiId: z.string().min(1),
    path: z.string().min(1),
  });
  
  export const WikiUpdatePageRequestSchema = z.object({
    organization: z.string().min(1).optional(),
    project: z.string().min(1).optional(),
    wikiId: z.string().min(1),
    path: z.string().min(1),
    content: z.string(),
  });
  
  export const WikiListRequestSchema = z.object({
    organization: z.string().min(1).optional(),
    project: z.string().min(1).optional(),
  });
  
  export type WikiSearchRequest = z.infer<typeof WikiSearchRequestSchema>;
  export type WikiPageTreeRequest = z.infer<typeof WikiPageTreeRequestSchema>;
  export type WikiGetPageRequest = z.infer<typeof WikiGetPageRequestSchema>;
  export type WikiUpdatePageRequest = z.infer<typeof WikiUpdatePageRequestSchema>;
  export type WikiListRequest = z.infer<typeof WikiListRequestSchema>;
  
  export interface WikiSearchResult {
    title: string;
    url: string;
    content: string;
    project: string;
    wiki: string;
    pagePath: string;
  }