Skip to main content
Glama
enesjakozh
nylas-samples

Nylas API MCP Server

Official
by nylas-samples
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Hybrid

generate-auth-code

Generate OAuth authorization code for Nylas API integration by specifying programming language and authentication parameters to connect email, calendar, and contacts functionality.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
languageYes
clientIdNo
clientSecretNo
redirectUriNo
scopesNo

Implementation Reference

  • src/tools/index.ts:29-228 (handler)
    The handler function generates authentication code snippets for the specified language (Node, Python, Java, Ruby, curl) using pre-defined templates, filling in placeholders for client credentials and scopes.
        async ({ language, clientId, clientSecret, redirectUri, scopes }) => {
      const normalizedLanguage = normalizeLanguage(language);
      const placeholderClientId = clientId || "YOUR_CLIENT_ID";
      const placeholderClientSecret = clientSecret || "YOUR_CLIENT_SECRET";
      const placeholderRedirectUri = redirectUri || "YOUR_REDIRECT_URI";
      const placeholderScopes = scopes || ["email", "calendar", "contacts"];
      
      // Map of languages to their authentication code templates
      const templates: Record<string, string> = {
        "Node": `
// Authentication with Nylas API using Node.js
import { Nylas } from '@nylas/nylas-js';

// Initialize Nylas client
Nylas.config({
  clientId: "${placeholderClientId}",
  clientSecret: "${placeholderClientSecret}",
});

// Generate OAuth URL to redirect the user to
const authUrl = Nylas.urlForAuthentication({
  redirectURI: "${placeholderRedirectUri}",
  scopes: ${JSON.stringify(placeholderScopes)},
});

console.log("Redirect the user to:", authUrl);

// After the user is redirected back to your redirect URI:
// Exchange the authorization code for an access token
async function exchangeCodeForToken(code) {
  try {
    const tokenData = await Nylas.exchangeCodeForToken(code);
    console.log("Access token:", tokenData.accessToken);
    console.log("Grant ID:", tokenData.grantId);
    
    // Now you can use this token to make API calls
    return tokenData;
  } catch (error) {
    console.error("Error exchanging code for token:", error);
  }
}

// Call this function with the code from the URL parameter
// exchangeCodeForToken(codeFromUrl);
`,

        "Python": `
# Authentication with Nylas API using Python
from nylas import Client
import os

# Initialize Nylas client
nylas = Client(
    client_id="${placeholderClientId}",
    client_secret="${placeholderClientSecret}"
)

# Generate OAuth URL to redirect the user to
auth_url = nylas.authentication_url(
    redirect_uri="${placeholderRedirectUri}",
    scopes=${placeholderScopes}
)

print("Redirect the user to:", auth_url)

# After the user is redirected back to your redirect URI:
# Exchange the authorization code for an access token
def exchange_code_for_token(code):
    try:
        token_data = nylas.exchange_code_for_token(code)
        print("Access token:", token_data['access_token'])
        print("Grant ID:", token_data['grant_id'])
        
        # Now you can use this token to make API calls
        return token_data
    except Exception as e:
        print("Error exchanging code for token:", e)

# Call this function with the code from the URL parameter
# exchange_code_for_token(code_from_url)
`,

        "Java": `
// Authentication with Nylas API using Java
import com.nylas.NylasClient;
import com.nylas.models.*;

public class NylasAuth {
    public static void main(String[] args) {
        // Initialize Nylas client
        NylasClient nylas = new NylasClient.Builder("${placeholderClientId}")
            .clientSecret("${placeholderClientSecret}")
            .build();
            
        // Generate OAuth URL to redirect the user to
        String authUrl = nylas.auth().urlForAuthentication(
            "${placeholderRedirectUri}", 
            ${placeholderScopes.map(scope => '"' + scope + '"').join(", ")}
        );
        
        System.out.println("Redirect the user to: " + authUrl);
        
        // After the user is redirected back to your redirect URI:
        // Exchange the authorization code for an access token
        String code = "CODE_FROM_URL_PARAMETER";
        
        try {
            TokenResponse tokenData = nylas.auth().exchangeCodeForToken(code);
            System.out.println("Access token: " + tokenData.getAccessToken());
            System.out.println("Grant ID: " + tokenData.getGrantId());
            
            // Now you can use this token to make API calls
        } catch (Exception e) {
            System.err.println("Error exchanging code for token: " + e.getMessage());
        }
    }
}
`,

        "Ruby": `
# Authentication with Nylas API using Ruby
require 'nylas'

# Initialize Nylas client
nylas = Nylas::Client.new(
  client_id: "${placeholderClientId}",
  client_secret: "${placeholderClientSecret}"
)

# Generate OAuth URL to redirect the user to
auth_url = nylas.auth.authorize_url(
  redirect_uri: "${placeholderRedirectUri}",
  scopes: ${JSON.stringify(placeholderScopes)}
)

puts "Redirect the user to: #{auth_url}"

# After the user is redirected back to your redirect URI:
# Exchange the authorization code for an access token
def exchange_code_for_token(code)
  begin
    token_data = nylas.auth.exchange_code_for_token(code)
    puts "Access token: #{token_data.access_token}"
    puts "Grant ID: #{token_data.grant_id}"
    
    # Now you can use this token to make API calls
    return token_data
  rescue => e
    puts "Error exchanging code for token: #{e.message}"
  end
end

# Call this function with the code from the URL parameter
# exchange_code_for_token(code_from_url)
`,

        "curl": `
# Authentication with Nylas API using curl

# Step 1: Generate an authorization URL (typically done in your backend)
# Users will be redirected to this URL to authorize your application

# Step 2: After authorization, the user is redirected to your redirect URI with a code
# For example: ${placeholderRedirectUri}?code=AUTHORIZATION_CODE

# Step 3: Exchange the authorization code for an access token
curl --request POST \\
  --url "https://api.us.nylas.com/v3/connect/oauth/token" \\
  --header "Content-Type: application/json" \\
  --data '{
    "client_id": "${placeholderClientId}",
    "client_secret": "${placeholderClientSecret}",
    "grant_type": "authorization_code",
    "code": "AUTHORIZATION_CODE_FROM_REDIRECT",
    "redirect_uri": "${placeholderRedirectUri}"
  }'

# Response will contain access_token, refresh_token, grant_id, etc.

# Step 4: Use the access token to make API calls
curl --request GET \\
  --url "https://api.us.nylas.com/v3/grants/GRANT_ID/messages?limit=10" \\
  --header "Content-Type: application/json" \\
  --header "Authorization: Bearer ACCESS_TOKEN"
`
      };
      
      // Get the template for the requested language, or provide an error message
      const template = templates[normalizedLanguage] || 
        `Code generation is not available for ${language}. Available languages are: Node.js, Python, Java, Ruby, and curl.`;
      
      return {
        content: [
          {
            type: "text",
            text: template
          }
        ]
      };
    }
  • src/tools/index.ts:23-28 (schema)
    Zod schema defining the input parameters for the generate-auth-code tool.
      language: z.enum(["node", "python", "java", "ruby", "curl"]),
  clientId: z.string().optional(),
  clientSecret: z.string().optional(),
  redirectUri: z.string().optional(),
  scopes: z.array(z.string()).optional()
},
  • src/tools/index.ts:20-229 (registration)
    Registration of the 'generate-auth-code' tool on the MCP server inside registerCodeGenerationTools.
      server.tool(
    "generate-auth-code",
    {
      language: z.enum(["node", "python", "java", "ruby", "curl"]),
      clientId: z.string().optional(),
      clientSecret: z.string().optional(),
      redirectUri: z.string().optional(),
      scopes: z.array(z.string()).optional()
    },
    async ({ language, clientId, clientSecret, redirectUri, scopes }) => {
      const normalizedLanguage = normalizeLanguage(language);
      const placeholderClientId = clientId || "YOUR_CLIENT_ID";
      const placeholderClientSecret = clientSecret || "YOUR_CLIENT_SECRET";
      const placeholderRedirectUri = redirectUri || "YOUR_REDIRECT_URI";
      const placeholderScopes = scopes || ["email", "calendar", "contacts"];
      
      // Map of languages to their authentication code templates
      const templates: Record<string, string> = {
        "Node": `
// Authentication with Nylas API using Node.js
import { Nylas } from '@nylas/nylas-js';

// Initialize Nylas client
Nylas.config({
  clientId: "${placeholderClientId}",
  clientSecret: "${placeholderClientSecret}",
});

// Generate OAuth URL to redirect the user to
const authUrl = Nylas.urlForAuthentication({
  redirectURI: "${placeholderRedirectUri}",
  scopes: ${JSON.stringify(placeholderScopes)},
});

console.log("Redirect the user to:", authUrl);

// After the user is redirected back to your redirect URI:
// Exchange the authorization code for an access token
async function exchangeCodeForToken(code) {
  try {
    const tokenData = await Nylas.exchangeCodeForToken(code);
    console.log("Access token:", tokenData.accessToken);
    console.log("Grant ID:", tokenData.grantId);
    
    // Now you can use this token to make API calls
    return tokenData;
  } catch (error) {
    console.error("Error exchanging code for token:", error);
  }
}

// Call this function with the code from the URL parameter
// exchangeCodeForToken(codeFromUrl);
`,

        "Python": `
# Authentication with Nylas API using Python
from nylas import Client
import os

# Initialize Nylas client
nylas = Client(
    client_id="${placeholderClientId}",
    client_secret="${placeholderClientSecret}"
)

# Generate OAuth URL to redirect the user to
auth_url = nylas.authentication_url(
    redirect_uri="${placeholderRedirectUri}",
    scopes=${placeholderScopes}
)

print("Redirect the user to:", auth_url)

# After the user is redirected back to your redirect URI:
# Exchange the authorization code for an access token
def exchange_code_for_token(code):
    try:
        token_data = nylas.exchange_code_for_token(code)
        print("Access token:", token_data['access_token'])
        print("Grant ID:", token_data['grant_id'])
        
        # Now you can use this token to make API calls
        return token_data
    except Exception as e:
        print("Error exchanging code for token:", e)

# Call this function with the code from the URL parameter
# exchange_code_for_token(code_from_url)
`,

        "Java": `
// Authentication with Nylas API using Java
import com.nylas.NylasClient;
import com.nylas.models.*;

public class NylasAuth {
    public static void main(String[] args) {
        // Initialize Nylas client
        NylasClient nylas = new NylasClient.Builder("${placeholderClientId}")
            .clientSecret("${placeholderClientSecret}")
            .build();
            
        // Generate OAuth URL to redirect the user to
        String authUrl = nylas.auth().urlForAuthentication(
            "${placeholderRedirectUri}", 
            ${placeholderScopes.map(scope => '"' + scope + '"').join(", ")}
        );
        
        System.out.println("Redirect the user to: " + authUrl);
        
        // After the user is redirected back to your redirect URI:
        // Exchange the authorization code for an access token
        String code = "CODE_FROM_URL_PARAMETER";
        
        try {
            TokenResponse tokenData = nylas.auth().exchangeCodeForToken(code);
            System.out.println("Access token: " + tokenData.getAccessToken());
            System.out.println("Grant ID: " + tokenData.getGrantId());
            
            // Now you can use this token to make API calls
        } catch (Exception e) {
            System.err.println("Error exchanging code for token: " + e.getMessage());
        }
    }
}
`,

        "Ruby": `
# Authentication with Nylas API using Ruby
require 'nylas'

# Initialize Nylas client
nylas = Nylas::Client.new(
  client_id: "${placeholderClientId}",
  client_secret: "${placeholderClientSecret}"
)

# Generate OAuth URL to redirect the user to
auth_url = nylas.auth.authorize_url(
  redirect_uri: "${placeholderRedirectUri}",
  scopes: ${JSON.stringify(placeholderScopes)}
)

puts "Redirect the user to: #{auth_url}"

# After the user is redirected back to your redirect URI:
# Exchange the authorization code for an access token
def exchange_code_for_token(code)
  begin
    token_data = nylas.auth.exchange_code_for_token(code)
    puts "Access token: #{token_data.access_token}"
    puts "Grant ID: #{token_data.grant_id}"
    
    # Now you can use this token to make API calls
    return token_data
  rescue => e
    puts "Error exchanging code for token: #{e.message}"
  end
end

# Call this function with the code from the URL parameter
# exchange_code_for_token(code_from_url)
`,

        "curl": `
# Authentication with Nylas API using curl

# Step 1: Generate an authorization URL (typically done in your backend)
# Users will be redirected to this URL to authorize your application

# Step 2: After authorization, the user is redirected to your redirect URI with a code
# For example: ${placeholderRedirectUri}?code=AUTHORIZATION_CODE

# Step 3: Exchange the authorization code for an access token
curl --request POST \\
  --url "https://api.us.nylas.com/v3/connect/oauth/token" \\
  --header "Content-Type: application/json" \\
  --data '{
    "client_id": "${placeholderClientId}",
    "client_secret": "${placeholderClientSecret}",
    "grant_type": "authorization_code",
    "code": "AUTHORIZATION_CODE_FROM_REDIRECT",
    "redirect_uri": "${placeholderRedirectUri}"
  }'

# Response will contain access_token, refresh_token, grant_id, etc.

# Step 4: Use the access token to make API calls
curl --request GET \\
  --url "https://api.us.nylas.com/v3/grants/GRANT_ID/messages?limit=10" \\
  --header "Content-Type: application/json" \\
  --header "Authorization: Bearer ACCESS_TOKEN"
`
      };
      
      // Get the template for the requested language, or provide an error message
      const template = templates[normalizedLanguage] || 
        `Code generation is not available for ${language}. Available languages are: Node.js, Python, Java, Ruby, and curl.`;
      
      return {
        content: [
          {
            type: "text",
            text: template
          }
        ]
      };
    }
  );
  • src/tools/index.ts:516-533 (helper)
    Helper function to normalize language input strings to match template keys, used in the handler.
    function normalizeLanguage(language: string): string {
  const langMap: Record<string, string> = {
    'node': 'Node',
    'nodejs': 'Node',
    'javascript': 'Node',
    'js': 'Node',
    'python': 'Python',
    'py': 'Python',
    'java': 'Java',
    'ruby': 'Ruby',
    'rb': 'Ruby',
    'curl': 'curl',
    'api': 'curl',
    'rest': 'curl'
  };
  
  return langMap[language.toLowerCase()] || language;
}

Tool Definition Quality

D1/5.0
Behavior1/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Tool has no description.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness1/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Tool has no description.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Tool has no description.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Tool has no description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose1/5

Does the description clearly state what the tool does and how it differs from similar tools?

Tool has no description.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines1/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Tool has no description.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/nylas-samples/nylas-api-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server