If you switched from fragmented tools, you gain a single feed with results for repositories, users, issues, and pull requests. Jump to the clone URL, read the docs, and prepare a fast review in seconds.

Refine your results with sort options, connect powerful integrations, and build seule filters that narrow to a single repo. Create a workflow automation that runs in a dedicated window. Use args to pass parameters like repo, user, or label so each query returns exact targets.

Find something worth acting on? It creates a pull request or issue, or you can request a code review with teammates. You can cancel pending actions anytime, and all changes update in real time across the window and feed. Our platform автоматизировать tasks so routine checks run without manual clicks, saving time.

Connect Your Code Hosting Platforms: GitHub, GitLab, and Bitbucket

Make a single deepl-mcp-server instance the hub for all three platforms. In each host configuration, specify its token and the required webhooks, and configure translate-text on push, issue creation, and pull request events. The webhooks are configured to trigger translate-text on relevant events. This keeps commit history intact and content translated consistently across hosts while preserving authorship.

The dataflow models events as nodes in a dataframe-like structure: fields include repository, actor, event_type, content, language, translated_content, and related metadata. Use filter to focus on specified repos, sort by last_push, and apply a window to batch process results. The translator can switch between deeplx and a local savoir or tisfeng profile, controlled by a request to the deepl-mcp-server. The setup also supports multiple mcpservers by duplicating host blocks. Logs provide history for auditability.

No-code dashboards surface translated content for review: translated_content alongside the original content and a status image representing results. The authors themselves remain credited after translation. The results dataframe can be exported or pushed back to the host as comments, preserving the original content and history. The system supports local processing or remote processing and can apply translate-text to related content; store both versions in the content field for easy comparison and rollback.

Tips for reliable syncing

Keep the translation window small for near real-time updates, use filter to surface relevant commits and issue notes, and store both translated and original in a dedicated content field to aid review. For Bitbucket, verify encoding; for GitHub and GitLab, validate webhook retries and ensure commit messages reflect translated content when pushed. Use mcpservers to monitor request success rates and adjust the specified scopes if needed.

Set Up API Access: Tokens, OAuth, and Scoped Permissions

Use a single auth_key for automated calls and an OAuth flow for interactive actions. Generate the key in the admin console, then store it in a trusted secret manager and reference it in your environment (e.g., AUTH_KEY=...). Rotate tokens every 90 days and revoke immediately if a credential is compromised. For tisfeng teams, create a dedicated app named "tisfeng-api" to separate access from other tools, and keep the token scope minimal to reduce risk. When cloning content or triggering workflows, pass the key in the Authorization header and avoid embedding it in logs. Reference it as auth_key in your config to avoid casing issues.

Grant only the required scopes for each integration. Different resources require different permissions; apply scoped permissions like read_content, write_issues, read_pull_requests. Review the docs feed for the supported scopes and keep the last updated list in hand. When your workflow translates user-facing content, respect targetlang values and use a dictionary to keep terminology consistent. Anything that touches sensitive data should be approved by security. Logs should never reveal full tokens; rotate them after a refresh. In addition, consider handling and storing small tokens as words of a dictionary to simplify audits.

OAuth flow details: register an OAuth app under your organization, e.g., tisfeng. Note client_id and client_secret; define a redirect_uri. Request authorization with scopes corresponding to the resources you need; exchange the authorization code for an access_token. If the platform supports refresh tokens, store the refresh_token securely and refresh it before expiry. Use a short-lived access token for critical operations and a longer-lived refresh token for background tasks. Include the access token in API calls via Authorization: Bearer . This approach supports interactive actions in the UI and automation in pipelines.

Token management and configuration: store tokens in a secret store and reload configurations without restarting services. Use environment variables like API_AUTH_KEY or DEEPLX when integrating a translator. If you are installing client libraries, follow the recommended installation steps. For single-token setups, rotate the key every 30-60 days and verify access by hitting a light-weight endpoint like GET /status. Keep last used scopes in your docs for audit. If you see a leak, revoke immediately and issue a new auth_key. For clone, reuse the token across multiple actions, but avoid cross-project access.

Testing and validation: run integration tests that cover repository search, user lookups, issue reads, and pull request actions. Use the provided test feed to confirm permissions and handling of errors. Validate that translations and content generation respect targetlang and dictionary updates. Maintain a changelog in docs and a heartbeat check in the actions workflow to ensure tokens remain valid. If you support multiple languages, ensure a smooth workflow by caching dictionary entries between requests and reloading them when updated. Anything else requires updating the feed promptly.

Define Repository Scope: Include, Exclude, and Default Search Boundaries

Recommendation: Define a single default scope per repository group that includes issues, pull requests (requests), commits, files, workflows, and the events that connect them. Each commit carries history. Limit the number to number 200 items per repo and keep the window to 30 days so you can quickly review and refresh results in the feed while staying within performance bounds.

Inclusion rules focus on where the search runs: include all githubs in the target org, patterns like mcpservers/* and local/* that represent active development, and related concepts such as labels, reviews, and event streams.

Exclusions cover artifacts that inflate results: node_modules, dist, build outputs, vendor directories, large binaries, generated files, and local config files such as .env.

Default boundaries set how the search behaves by default: sort by updated_at, keep within the 200 item limit per repo, apply a 30 day window, and index content using vector embeddings for fast vector search across nodes. The boundary applies within each repository, and history with issues and events remains within the scope; refresh the index every 24 hours, and set controls so IT ops can manage the feed efficiently that itops en-us quickly review and act.

Area Include Exclude Default Boundaries
Target Repositories githubs in the org, patterns like mcpservers/*, local/* external forks, archived or sandbox repos Apply to all included repos; prevent cross org leakage
Content Types issues, pull requests (requests), commits, files, workflows, events, reviews, related feed items binary assets, generated files, large PDFs, vendor files Index items touching code and discussions only; limit to 30 days
Queries & Sorting sort by updated_at; use vector search for quick results exceed 200 items per repo per query Top results per repo based on recency
Localization & Usage en-us locale, usage hints for itops non localized content refresh cadence 24 hours; feed to monitoring dashboards

Index Users and Roles: Map Fields to the Search Schema

Index users and roles by mapping core fields to the search schema and maintain a dataframe-based pipeline to keep data in sync across profiles and sessions. Use en-us localization for user-facing results and enable translate pipelines to support multilingual teams.

Build a mapping that stores fields in a structured, query-friendly form, speeding handling of requests, role lookups, and access checks. Ensure each field has a clear type and search behavior: user_id and email as keyword, username as text with a keyword subfield, created_at and last_login as date, locale and time_zone as keyword, and status as keyword.

Field Mapping Strategy

User fields: user_id (keyword), username (text, with a keyword subfield), email (keyword), locale (keyword, example en-us), time_zone (keyword), status (keyword), created_at (date), last_login (date). Link roles via role_ids (keyword) and role_names (text). For roles: role_id (keyword), name (text), scope (keyword), permissions (codes nested). Role fields: role_id (keyword), name (text), scope (keyword), permissions (codes, nested), categories (keyword). Map profiles to a nested structure when needed so queries can target specific aspects like identity, role, or permissions without fetching whole records.

Operational Processes

Index updates trigger on profile or role changes. The process creates a mapping version when updates occur and can clone the previous mapping to produce the new variant, then reindexes via the orchestration layer. This keeps results consistent for page-based admin views and audits. The pipeline handles extraction, transformation to the search schema, and load steps, with a focus on handling errors gracefully and logging requests for traceability.

Localization and translation considerations: apply translate with targetlang to produce en-us results by default, and use Bing or similar engines for alternate locales when needed. Build the process to be free-text friendly for user searches and to support both simple and advanced queries. The system should secure sensitive fields in transit and at rest, and provide clear savoir-friendly guidance in the UI for admins who configure permissions and access controls.

Index Issues and Pull Requests: Capture States, Labels, Milestones, and Comments

Recommendation: implement a centralized index that captures each issue and pull request as a structured record with fields: number, type (issue or pull_request), state, title, body_snippet, labels, milestone, author, assignees, comments, last_updated. This enables fast searches and precise filtering by state, label, or milestone. Keep a local cache to support free, no-code dashboards and offline usage, and dispatch updates on changes to ensure the index stays current. For teams like tisfeng, this approach scales with mcpservers integrations and secure access controls.

Schema, Detected Words, and Automation

Define a compact schema: number (integer), type (string), state (string), title (string), body_snippet (string), labels (array of strings), milestone (string or null), author (string), assignees (array), comments (array with user, text, created_at), last_updated (timestamp). Add a setdetected boolean when a keyword from the words list appears in title or comments. Use automate to trigger workflows and dispatch tasks that update labels or move items between states. This lets you search by number, words in titles, or labels, and youre able to manage multiple projects from a single page.

Operational Guidance and Metrics

Implementation steps: 1) pull data from sources, 2) store in a local index (SQLite or JSON) with fields above, 3) expose a page for filters by state, labels, and milestone, 4) run nightly or event-driven dispatch to refresh index, 5) enforce usage limits and security, 6) purge duplicates with delete after verification. Track metrics: indexed items count, average comments per item, index freshness, and response times for searches. Use free integrations and workflows to keep the process lightweight and scalable, and ensure that all changes stay within secure access controls and clear related usage terms.

Refine and Filter Results: Language, Owner, Date Range, and Status Facets

Recommendation: Set targetlang to en-us and apply Language first, then cascade filters by Owner, Date Range, and Status to quickly narrow results and improve review throughput. systeme coordinates the facets and keeps results consistent across requests and tasks.

Facet usage

Practical steps and integrations

  1. Save common combinations in Settings to create a repeatable view; you can use the free, basic plan to prototype filters before scaling.
  2. Push updates automatically via webhook when results cross a status boundary; use dispatch to route items to the right queues for content reviewing and translation tasks.
  3. Clone result sets for safe experimentation without altering the main view; leverage tools and content reviews to ensure safe handling and review by translators.
  4. Leverage search plugins and basic bing results to broaden discovery where internal data is sparse; ensure that en-us results stay in focus for consistency.

Schedule Refresh, Caching, and Error Handling for Reliable Results

Recommendation: set a 5-minute refresh window for their issues, pulls, and user data, and implement a two-tier cache: in-memory on mcpservers and nodes for quick hits and a shared Redis-backed store for durability. This basic strategy quickly delivers results while preserving history across languages and content history, and it automates reloads to keep content fresh.

By combining a disciplined refresh window, two-tier caching, robust error handling, and automated content rephrase flows, you achieve reliable results, faster reloads, and smooth user interactions across languages and repositories.