Tabnine

┌─────────────────────────────────────────────────────────┐
│                    TABNINE PRIVACY                       │
├─────────────────────────────────────────────────────────┤
│                                                         │
│   [Your Code] ──→ [Local Analysis] ──→ [Suggestions]   │
│        │                                     │          │
│        └────────────── NOT ─────────────────┘          │
│                  sent to the cloud                      │
│                                                         │
│   ✓ Code stays on your device                          │
│   ✓ No snippets are stored                             │
│   ✓ No training data from your code                    │
│   ✓ Full GDPR/HIPAA/SOC2 compliance                    │
│                                                         │
└─────────────────────────────────────────────────────────┘

Your IDE ──→ TLS 1.3 ──→ Tabnine Cloud ──→ Suggestions
              │
              └─ Zero data retention
              └─ Data is not used for training

Your IDE ──→ VPC ──→ Your infrastructure ──→ Tabnine Server
              │              │
              └─ Private network
                             └─ AI model on your servers

Your IDE ──→ [NO INTERNET] ──→ Local Tabnine Server
                                        │
                                        └─ Completely offline
                                        └─ Zero external connections

# 1. Open VS Code
# 2. Extensions (Ctrl+Shift+X)
# 3. Search for "Tabnine"
# 4. Install "Tabnine AI Autocomplete"

# Or from the terminal:
code --install-extension TabNine.tabnine-vscode

# 1. File → Settings → Plugins
# 2. Marketplace → Search "Tabnine"
# 3. Install → Restart IDE

# Or from CLI:
# Download plugin from JetBrains Marketplace

-- lazy.nvim
{
  "codota/tabnine-nvim",
  build = "./dl_binaries.sh",
  config = function()
    require('tabnine').setup({
      disable_auto_comment = true,
      accept_keymap = "<Tab>",
      dismiss_keymap = "<C-]>",
      debounce_ms = 800,
      suggestion_color = { gui = "#808080", cterm = 244 },
      exclude_filetypes = { "TelescopePrompt", "NvimTree" },
      log_file_path = nil,
    })
  end
}

" vim-plug
Plug 'codota/tabnine-vim'

" After installation
:TabnineStatus
:TabnineEnable
:TabnineDisable

1. Help → Eclipse Marketplace
2. Search "Tabnine"
3. Install → Accept license → Restart

1. Extensions → Manage Extensions
2. Online → Search "Tabnine"
3. Download → Restart VS

// Tabnine understands context and predicts the next code

// I start typing:
interface User {
  id: string
  email: string
  name: string
  createdAt: Date
}

async function getUserById(|
// Tabnine suggests:
// → id: string): Promise<User | null> {
//     return await prisma.user.findUnique({ where: { id } })
//   }

// After accepting and starting a new function:
async function createUser(|
// Tabnine suggests the entire function:
// → data: Omit<User, 'id' | 'createdAt'>): Promise<User> {
//     return await prisma.user.create({ data })
//   }

# Tabnine can suggest entire code blocks

class UserRepository:
    def __init__(self, db):
        self.db = db

    def find_by_email(self|
    # Tabnine suggests:
    # → , email: str) -> Optional[User]:
    #       """Find user by email address."""
    #       return self.db.query(User).filter(User.email == email).first()

    def create(self|
    # Tabnine continues the pattern:
    # → , user_data: UserCreate) -> User:
    #       """Create a new user."""
    #       user = User(**user_data.dict())
    #       self.db.add(user)
    #       self.db.commit()
    #       self.db.refresh(user)
    #       return user

// Tabnine learns the conventions of your project

// If your project always uses:
const fetchUsers = async () => {
  const response = await api.get('/users')
  return response.data
}

// Then for a new function:
const fetchPosts = |
// Tabnine suggests following your pattern:
// → async () => {
//     const response = await api.get('/posts')
//     return response.data
//   }

┌─────────────────────────────────────────────────────────┐
│              TABNINE PERSONALIZATION                     │
├─────────────────────────────────────────────────────────┤
│                                                         │
│   1. Project structure analysis                         │
│      └─ Folders, files, modules                        │
│                                                         │
│   2. Learning naming conventions                       │
│      └─ camelCase, snake_case, prefixes               │
│                                                         │
│   3. Pattern recognition                               │
│      └─ Error handling, logging, API calls            │
│                                                         │
│   4. Library adaptation                                │
│      └─ React, Vue, Django, Spring, etc.              │
│                                                         │
│   5. Style personalization                             │
│      └─ Formatting, comments, structure               │
│                                                         │
└─────────────────────────────────────────────────────────┘

# Tabnine can learn from your entire team's code
# (Enterprise only, with full admin control)

team_learning:
  enabled: true
  repositories:
    - company/frontend-app
    - company/backend-api
    - company/shared-utils

  excluded_patterns:
    - "**/.env*"
    - "**/secrets/**"
    - "**/*credentials*"

  sync_frequency: "daily"
  retention_period: "90_days"

// .tabnine.json in the project root
{
  "version": "1.0.0",
  "suggestions": {
    "enabled": true,
    "debounce_ms": 150,
    "min_confidence": 0.8
  },
  "context": {
    "include_imports": true,
    "max_context_lines": 500,
    "include_similar_files": true
  },
  "preferences": {
    "prefer_single_line": false,
    "include_docstrings": true,
    "language_specific": {
      "typescript": {
        "prefer_interfaces": true,
        "use_arrow_functions": true
      },
      "python": {
        "prefer_type_hints": true,
        "use_dataclasses": true
      }
    }
  }
}

// Cmd+Shift+T opens Tabnine Chat in VS Code

// Select code and ask for an explanation:
// "Explain this code"

function memoize<T extends (...args: any[]) => any>(
  fn: T,
  keyFn?: (...args: Parameters<T>) => string
): T {
  const cache = new Map<string, ReturnType<T>>()

  return ((...args: Parameters<T>): ReturnType<T> => {
    const key = keyFn ? keyFn(...args) : JSON.stringify(args)

    if (cache.has(key)) {
      return cache.get(key)!
    }

    const result = fn(...args)
    cache.set(key, result)
    return result
  }) as T
}

// Tabnine Chat will explain:
// "This function implements memoization - a technique for caching
// function results. When the function is called with the same
// arguments, it returns the cached result instead of
// recalculating..."

User: Create a React hook for debouncing a value

Tabnine Chat:

import { useState, useEffect } from 'react'

function useDebounce<T>(value: T, delay: number): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value)

  useEffect(() => {
    const timer = setTimeout(() => {
      setDebouncedValue(value)
    }, delay)

    return () => {
      clearTimeout(timer)
    }
  }, [value, delay])

  return debouncedValue
}

// Usage:
function SearchComponent() {
  const [search, setSearch] = useState('')
  const debouncedSearch = useDebounce(search, 300)

  useEffect(() => {
    if (debouncedSearch) {
      // Perform the search
      fetchResults(debouncedSearch)
    }
  }, [debouncedSearch])

  return (
    <input
      value={search}
      onChange={(e) => setSearch(e.target.value)}
      placeholder="Search..."
    />
  )
}

User: Refactor this code to the Repository pattern

Tabnine Chat analyzes the code and proposes:

// Before refactoring:
async function getUser(id: string) {
  const user = await db.query('SELECT * FROM users WHERE id = ?', [id])
  return user
}

async function createUser(data: UserData) {
  await db.query('INSERT INTO users ...', [data])
}

// After refactoring (Tabnine Chat):
interface IUserRepository {
  findById(id: string): Promise<User | null>
  create(data: CreateUserDTO): Promise<User>
  update(id: string, data: UpdateUserDTO): Promise<User>
  delete(id: string): Promise<void>
}

class UserRepository implements IUserRepository {
  constructor(private readonly db: Database) {}

  async findById(id: string): Promise<User | null> {
    const result = await this.db.query<User>(
      'SELECT * FROM users WHERE id = ?',
      [id]
    )
    return result[0] || null
  }

  async create(data: CreateUserDTO): Promise<User> {
    const id = generateId()
    await this.db.query(
      'INSERT INTO users (id, email, name) VALUES (?, ?, ?)',
      [id, data.email, data.name]
    )
    return this.findById(id) as Promise<User>
  }

  async update(id: string, data: UpdateUserDTO): Promise<User> {
    const fields = Object.entries(data)
      .map(([key]) => `${key} = ?`)
      .join(', ')
    const values = Object.values(data)

    await this.db.query(
      `UPDATE users SET ${fields} WHERE id = ?`,
      [...values, id]
    )
    return this.findById(id) as Promise<User>
  }

  async delete(id: string): Promise<void> {
    await this.db.query('DELETE FROM users WHERE id = ?', [id])
  }
}

# docker-compose.yml for Tabnine Enterprise
version: '3.8'

services:
  tabnine-server:
    image: tabnine/enterprise-server:latest
    ports:
      - "8080:8080"
      - "8443:8443"
    environment:
      - LICENSE_KEY=${TABNINE_LICENSE}
      - ADMIN_EMAIL=${ADMIN_EMAIL}
      - SSL_ENABLED=true
    volumes:
      - tabnine-data:/var/lib/tabnine
      - ./certs:/etc/tabnine/certs
    deploy:
      resources:
        limits:
          memory: 16G
        reservations:
          memory: 8G

  tabnine-model:
    image: tabnine/model-server:latest
    environment:
      - MODEL_SIZE=large
      - GPU_ENABLED=true
    deploy:
      resources:
        reservations:
          devices:
            - capabilities: [gpu]

volumes:
  tabnine-data:

# tabnine-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: tabnine-enterprise
  namespace: devtools
spec:
  replicas: 3
  selector:
    matchLabels:
      app: tabnine
  template:
    metadata:
      labels:
        app: tabnine
    spec:
      containers:
        - name: tabnine-server
          image: tabnine/enterprise-server:latest
          ports:
            - containerPort: 8080
          resources:
            requests:
              memory: "8Gi"
              cpu: "4"
            limits:
              memory: "16Gi"
              cpu: "8"
          envFrom:
            - secretRef:
                name: tabnine-secrets
          livenessProbe:
            httpGet:
              path: /health
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: tabnine-service
spec:
  selector:
    app: tabnine
  ports:
    - port: 443
      targetPort: 8080
  type: LoadBalancer

// Tabnine Enterprise Admin API

// User management
const adminApi = new TabnineAdminAPI({
  baseUrl: 'https://tabnine.company.com',
  apiKey: process.env.TABNINE_ADMIN_KEY
})

// Adding users
await adminApi.users.create({
  email: 'developer@company.com',
  team: 'frontend',
  role: 'developer'
})

// Usage statistics
const stats = await adminApi.analytics.getUsageStats({
  from: '2024-01-01',
  to: '2024-01-31',
  groupBy: 'team'
})

console.log(stats)
// {
//   teams: {
//     frontend: { suggestions_accepted: 15420, time_saved_hours: 230 },
//     backend: { suggestions_accepted: 12350, time_saved_hours: 185 },
//   },
//   total_suggestions: 27770,
//   acceptance_rate: 0.34
// }

// Policy management
await adminApi.policies.update({
  team: 'security',
  settings: {
    allow_cloud_suggestions: false,
    require_local_model: true,
    audit_all_suggestions: true
  }
})

# config/auth.yaml
authentication:
  type: saml
  saml:
    idp_metadata_url: https://idp.company.com/metadata.xml
    sp_entity_id: https://tabnine.company.com
    assertion_consumer_service_url: https://tabnine.company.com/saml/acs
    name_id_format: emailAddress

  attribute_mapping:
    email: http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress
    name: http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name
    groups: http://schemas.microsoft.com/ws/2008/06/identity/claims/groups

  group_sync:
    enabled: true
    admin_groups:
      - CN=Tabnine-Admins,OU=Groups,DC=company,DC=com
    user_groups:
      - CN=Developers,OU=Groups,DC=company,DC=com

┌─────────────────────────────────────────────────────────┐
│              TABNINE CERTIFICATIONS                      │
├─────────────────────────────────────────────────────────┤
│                                                         │
│   ✓ SOC 2 Type II                                      │
│     └─ Audited security controls                       │
│                                                         │
│   ✓ GDPR Compliant                                     │
│     └─ Full compliance with EU regulations             │
│                                                         │
│   ✓ HIPAA Ready                                        │
│     └─ For the healthcare sector                       │
│                                                         │
│   ✓ ISO 27001                                          │
│     └─ Information security management system          │
│                                                         │
│   ✓ CCPA Compliant                                     │
│     └─ California Consumer Privacy Act                 │
│                                                         │
└─────────────────────────────────────────────────────────┘

# Tabnine data policy
data_policy:
  code_snippets:
    storage: none  # Never stored
    transmission: encrypted_tls_1.3
    training: never  # Never used for training

  telemetry:
    collected:
      - suggestion_acceptance_rate
      - feature_usage
      - error_reports
    not_collected:
      - code_content
      - file_names
      - project_structure

  retention:
    session_data: 0_days  # Immediately deleted
    analytics: 90_days
    audit_logs: 1_year

// Tabnine does not suggest code with potential vulnerabilities

// ❌ Tabnine will NOT suggest:
const query = `SELECT * FROM users WHERE id = '${userId}'` // SQL Injection

// ✅ Tabnine will suggest:
const user = await prisma.user.findUnique({
  where: { id: userId }
})

// ❌ Tabnine will NOT suggest:
res.send(`<div>${userInput}</div>`) // XSS

// ✅ Tabnine will suggest:
import { escape } from 'html-escaper'
res.send(`<div>${escape(userInput)}</div>`)

// ❌ Tabnine will NOT suggest:
const password = "admin123" // Hardcoded credentials

// ✅ Tabnine will suggest:
const password = process.env.DB_PASSWORD

# Tabnine can analyze git history for better suggestions

# Configuration in settings:
{
  "tabnine.gitContext": {
    "enabled": true,
    "includeCommitHistory": true,
    "includeBranchInfo": true,
    "maxCommits": 100
  }
}

# .github/workflows/tabnine-metrics.yml
name: Tabnine Metrics

on:
  schedule:
    - cron: '0 0 * * 1'  # Weekly

jobs:
  collect-metrics:
    runs-on: ubuntu-latest
    steps:
      - name: Collect Tabnine Usage
        uses: tabnine/metrics-action@v1
        with:
          api-key: ${{ secrets.TABNINE_API_KEY }}
          output-format: json

      - name: Post to Slack
        uses: slackapi/slack-github-action@v1
        with:
          payload: |
            {
              "text": "Weekly Tabnine Report",
              "blocks": [
                {
                  "type": "section",
                  "text": {
                    "type": "mrkdwn",
                    "text": "Suggestions accepted: ${{ steps.metrics.outputs.accepted }}\nTime saved: ${{ steps.metrics.outputs.hours_saved }} hours"
                  }
                }
              ]
            }

// Tabnine Enterprise can send reports to Slack

// Webhook configuration
const slackWebhook = new TabnineSlackIntegration({
  webhookUrl: process.env.SLACK_WEBHOOK,
  channel: '#dev-metrics'
})

// Weekly report
slackWebhook.scheduleReport({
  frequency: 'weekly',
  metrics: ['acceptance_rate', 'time_saved', 'top_users'],
  format: 'detailed'
})

// 1. Write good docstrings/comments
/**
 * Calculates the total price including tax and discounts
 * @param items - Array of cart items
 * @param taxRate - Tax rate as decimal (e.g., 0.23 for 23%)
 * @param discountCode - Optional discount code
 * @returns Total price after all calculations
 */
function calculateTotal(items: CartItem[], taxRate: number, discountCode?: string) {
  // Tabnine understands context from the docstring and suggests better
}

// 2. Use descriptive names
// ❌
const d = getData()

// ✅
const userProfileData = fetchUserProfile()

// 3. Maintain consistent patterns
// If you always use async/await:
const user = await getUser(id)
const posts = await getPosts(userId)
// Tabnine will continue this pattern

// 4. Define types
interface Product {
  id: string
  name: string
  price: number
  category: string
}
// Tabnine uses types for better suggestions

// .vscode/settings.json (shared in the repo)
{
  "tabnine.experimentalAutoImports": true,
  "tabnine.debounceMilliseconds": 200,
  "tabnine.useProperIdentifiers": true,

  // Team preferences
  "tabnine.preferences": {
    "preferArrowFunctions": true,
    "preferConstOverLet": true,
    "includeTypeAnnotations": true
  }
}

# 1. Check Tabnine status
# VS Code: Ctrl+Shift+P → "Tabnine: Status"

# 2. Restart Tabnine
# VS Code: Ctrl+Shift+P → "Tabnine: Restart"

# 3. Check memory usage
ps aux | grep -i tabnine

# 4. Increase memory (settings.json)
{
  "tabnine.maxMemory": 4096
}

# 1. Check if the file type is supported
# Tabnine supports: JS, TS, Python, Java, C++, Go, Ruby, Rust, etc.

# 2. Check settings
{
  "tabnine.disable_file_patterns": []  # Make sure you're not blocking anything
}

# 3. Check your license
# VS Code: Ctrl+Shift+P → "Tabnine: Open Hub"

// Disable competing autocompletion
{
  "editor.suggest.showSnippets": false,
  "javascript.suggest.enabled": false,
  "typescript.suggest.enabled": false,

  // Priority for Tabnine
  "editor.quickSuggestions": {
    "other": true,
    "comments": false,
    "strings": true
  }
}